diff --git a/src/applications/calendar/query/PhabricatorCalendarEventQuery.php b/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
index 5d06001890..06eb50cc54 100644
--- a/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
+++ b/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
@@ -1,528 +1,552 @@
 <?php
 
 final class PhabricatorCalendarEventQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $ids;
   private $phids;
   private $rangeBegin;
   private $rangeEnd;
   private $inviteePHIDs;
   private $hostPHIDs;
   private $isCancelled;
   private $eventsWithNoParent;
   private $instanceSequencePairs;
   private $isStub;
 
   private $generateGhosts = false;
 
   public function newResultObject() {
     return new PhabricatorCalendarEvent();
   }
 
   public function setGenerateGhosts($generate_ghosts) {
     $this->generateGhosts = $generate_ghosts;
     return $this;
   }
 
   public function withIDs(array $ids) {
     $this->ids = $ids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function withDateRange($begin, $end) {
     $this->rangeBegin = $begin;
     $this->rangeEnd = $end;
     return $this;
   }
 
   public function withInvitedPHIDs(array $phids) {
     $this->inviteePHIDs = $phids;
     return $this;
   }
 
   public function withHostPHIDs(array $phids) {
     $this->hostPHIDs = $phids;
     return $this;
   }
 
   public function withIsCancelled($is_cancelled) {
     $this->isCancelled = $is_cancelled;
     return $this;
   }
 
   public function withIsStub($is_stub) {
     $this->isStub = $is_stub;
     return $this;
   }
 
   public function withEventsWithNoParent($events_with_no_parent) {
     $this->eventsWithNoParent = $events_with_no_parent;
     return $this;
   }
 
   public function withInstanceSequencePairs(array $pairs) {
     $this->instanceSequencePairs = $pairs;
     return $this;
   }
 
   protected function getDefaultOrderVector() {
     return array('start', 'id');
   }
 
   public function getBuiltinOrders() {
     return array(
       'start' => array(
         'vector' => array('start', 'id'),
         'name' => pht('Event Start'),
       ),
     ) + parent::getBuiltinOrders();
   }
 
   public function getOrderableColumns() {
     return array(
       'start' => array(
         'table' => $this->getPrimaryTableAlias(),
         'column' => 'dateFrom',
         'reverse' => true,
         'type' => 'int',
         'unique' => false,
       ),
     ) + parent::getOrderableColumns();
   }
 
   protected function getPagingValueMap($cursor, array $keys) {
     $event = $this->loadCursorObject($cursor);
     return array(
       'start' => $event->getStartDateTimeEpoch(),
       'id' => $event->getID(),
     );
   }
 
   protected function shouldLimitResults() {
     // When generating ghosts, we can't rely on database ordering because
     // MySQL can't predict the ghost start times. We'll just load all matching
     // events, then generate results from there.
     if ($this->generateGhosts) {
       return false;
     }
 
     return true;
   }
 
   protected function loadPage() {
     $events = $this->loadStandardPage($this->newResultObject());
 
     $viewer = $this->getViewer();
     foreach ($events as $event) {
       $event->applyViewerTimezone($viewer);
     }
 
     if (!$this->generateGhosts) {
       return $events;
     }
 
     $raw_limit = $this->getRawResultLimit();
 
     if (!$raw_limit && !$this->rangeEnd) {
       throw new Exception(
         pht(
           'Event queries which generate ghost events must include either a '.
           'result limit or an end date, because they may otherwise generate '.
           'an infinite number of results. This query has neither.'));
     }
 
     foreach ($events as $key => $event) {
       $sequence_start = 0;
       $sequence_end = null;
       $end = null;
 
       $instance_of = $event->getInstanceOfEventPHID();
 
       if ($instance_of == null && $this->isCancelled !== null) {
         if ($event->getIsCancelled() != $this->isCancelled) {
           unset($events[$key]);
           continue;
         }
       }
     }
 
     // Pull out all of the parents first. We may discard them as we begin
     // generating ghost events, but we still want to process all of them.
     $parents = array();
     foreach ($events as $key => $event) {
       if ($event->isParentEvent()) {
         $parents[$key] = $event;
       }
     }
 
     // Now that we've picked out all the parent events, we can immediately
     // discard anything outside of the time window.
     $events = $this->getEventsInRange($events);
 
-    $enforced_end = null;
+    $generate_from = $this->rangeBegin;
+    $generate_until = $this->rangeEnd;
     foreach ($parents as $key => $event) {
-      $sequence_start = 0;
-      $sequence_end = null;
-      $start = null;
-
       $duration = $event->getDuration();
 
-      $frequency = $event->getFrequencyUnit();
-      $modify_key = '+1 '.$frequency;
-
-      if (($this->rangeBegin !== null) &&
-          ($this->rangeBegin > $event->getStartDateTimeEpoch())) {
-        $max_date = $this->rangeBegin - $duration;
-        $date = $event->getStartDateTimeEpoch();
-        $datetime = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);
+      $start_date = $this->getRecurrenceWindowStart(
+        $event,
+        $generate_from - $duration);
 
-        while ($date < $max_date) {
-          // TODO: optimize this to not loop through all off-screen events
-          $sequence_start++;
-          $datetime = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);
-          $date = $datetime->modify($modify_key)->format('U');
-        }
+      $end_date = $this->getRecurrenceWindowEnd(
+        $event,
+        $generate_until);
 
-        $start = $this->rangeBegin;
-      } else {
-        $start = $event->getStartDateTimeEpoch() - $duration;
-      }
+      $limit = $this->getRecurrenceLimit($event, $raw_limit);
 
-      $date = $start;
-      $datetime = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);
+      $set = $event->newRecurrenceSet();
 
-      // Select the minimum end time we need to generate events until.
-      $end_times = array();
-      if ($this->rangeEnd) {
-        $end_times[] = $this->rangeEnd;
-      }
+      $recurrences = $set->getEventsBetween(
+        null,
+        $end_date,
+        $limit + 1);
 
-      if ($event->getUntilDateTimeEpoch()) {
-        $end_times[] = $event->getUntilDateTimeEpoch();
+      // We're generating events from the beginning and then filtering them
+      // here (instead of only generating events starting at the start date)
+      // because we need to know the proper sequence indexes to generate ghost
+      // events. This may change after RDATE support.
+      if ($start_date) {
+        $start_epoch = $start_date->getEpoch();
+      } else {
+        $start_epoch = null;
       }
 
-      if ($enforced_end) {
-        $end_times[] = $enforced_end;
-      }
+      foreach ($recurrences as $sequence_index => $sequence_datetime) {
+        if (!$sequence_index) {
+          // This is the parent event, which we already have.
+          continue;
+        }
 
-      if ($end_times) {
-        $end = min($end_times);
-        $sequence_end = $sequence_start;
-        while ($date < $end) {
-          $sequence_end++;
-          $datetime->modify($modify_key);
-          $date = $datetime->format('U');
-          if ($sequence_end > $raw_limit + $sequence_start) {
-            break;
+        if ($start_epoch) {
+          if ($sequence_datetime->getEpoch() < $start_epoch) {
+            continue;
           }
         }
-      } else {
-        $sequence_end = $raw_limit + $sequence_start;
-      }
 
-      $sequence_start = max(1, $sequence_start);
-      for ($index = $sequence_start; $index < $sequence_end; $index++) {
-        $events[] = $event->newGhost($viewer, $index);
+        $events[] = $event->newGhost(
+          $viewer,
+          $sequence_index,
+          $sequence_datetime);
       }
 
       // NOTE: We're slicing results every time because this makes it cheaper
       // to generate future ghosts. If we already have 100 events that occur
       // before July 1, we know we never need to generate ghosts after that
       // because they couldn't possibly ever appear in the result set.
 
       if ($raw_limit) {
         if (count($events) > $raw_limit) {
           $events = msort($events, 'getStartDateTimeEpoch');
           $events = array_slice($events, 0, $raw_limit, true);
-          $enforced_end = last($events)->getStartDateTimeEpoch();
+          $generate_until = last($events)->getEndDateTimeEpoch();
         }
       }
     }
 
     // Now that we're done generating ghost events, we're going to remove any
     // ghosts that we have concrete events for (or which we can load the
     // concrete events for). These concrete events are generated when users
     // edit a ghost, and replace the ghost events.
 
     // First, generate a map of all concrete <parentPHID, sequence> events we
     // already loaded. We don't need to load these again.
     $have_pairs = array();
     foreach ($events as $event) {
       if ($event->getIsGhostEvent()) {
         continue;
       }
 
       $parent_phid = $event->getInstanceOfEventPHID();
       $sequence = $event->getSequenceIndex();
 
       $have_pairs[$parent_phid][$sequence] = true;
     }
 
     // Now, generate a map of all <parentPHID, sequence> events we generated
     // ghosts for. We need to try to load these if we don't already have them.
     $map = array();
     $parent_pairs = array();
     foreach ($events as $key => $event) {
       if (!$event->getIsGhostEvent()) {
         continue;
       }
 
       $parent_phid = $event->getInstanceOfEventPHID();
       $sequence = $event->getSequenceIndex();
 
       // We already loaded the concrete version of this event, so we can just
       // throw out the ghost and move on.
       if (isset($have_pairs[$parent_phid][$sequence])) {
         unset($events[$key]);
         continue;
       }
 
       // We didn't load the concrete version of this event, so we need to
       // try to load it if it exists.
       $parent_pairs[] = array($parent_phid, $sequence);
       $map[$parent_phid][$sequence] = $key;
     }
 
     if ($parent_pairs) {
       $instances = id(new self())
         ->setViewer($viewer)
         ->setParentQuery($this)
         ->withInstanceSequencePairs($parent_pairs)
         ->execute();
 
       foreach ($instances as $instance) {
         $parent_phid = $instance->getInstanceOfEventPHID();
         $sequence = $instance->getSequenceIndex();
 
         $indexes = idx($map, $parent_phid);
         $key = idx($indexes, $sequence);
 
         // Replace the ghost with the corresponding concrete event.
         $events[$key] = $instance;
       }
     }
 
     $events = msort($events, 'getStartDateTimeEpoch');
 
     return $events;
   }
 
   protected function buildJoinClauseParts(AphrontDatabaseConnection $conn_r) {
     $parts = parent::buildJoinClauseParts($conn_r);
 
     if ($this->inviteePHIDs !== null) {
       $parts[] = qsprintf(
         $conn_r,
         'JOIN %T invitee ON invitee.eventPHID = event.phid
           AND invitee.status != %s',
         id(new PhabricatorCalendarEventInvitee())->getTableName(),
         PhabricatorCalendarEventInvitee::STATUS_UNINVITED);
     }
 
     return $parts;
   }
 
   protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
     $where = parent::buildWhereClauseParts($conn);
 
     if ($this->ids) {
       $where[] = qsprintf(
         $conn,
         'event.id IN (%Ld)',
         $this->ids);
     }
 
     if ($this->phids) {
       $where[] = qsprintf(
         $conn,
         'event.phid IN (%Ls)',
         $this->phids);
     }
 
     // NOTE: The date ranges we query for are larger than the requested ranges
     // because we need to catch all-day events. We'll refine this range later
     // after adjusting the visible range of events we load.
 
     if ($this->rangeBegin) {
       $where[] = qsprintf(
         $conn,
         '(event.utcUntilEpoch >= %d) OR (event.utcUntilEpoch IS NULL)',
         $this->rangeBegin - phutil_units('16 hours in seconds'));
     }
 
     if ($this->rangeEnd) {
       $where[] = qsprintf(
         $conn,
         'event.utcInitialEpoch <= %d',
         $this->rangeEnd + phutil_units('16 hours in seconds'));
     }
 
     if ($this->inviteePHIDs !== null) {
       $where[] = qsprintf(
         $conn,
         'invitee.inviteePHID IN (%Ls)',
         $this->inviteePHIDs);
     }
 
     if ($this->hostPHIDs) {
       $where[] = qsprintf(
         $conn,
         'event.hostPHID IN (%Ls)',
         $this->hostPHIDs);
     }
 
     if ($this->isCancelled !== null) {
       $where[] = qsprintf(
         $conn,
         'event.isCancelled = %d',
         (int)$this->isCancelled);
     }
 
     if ($this->eventsWithNoParent == true) {
       $where[] = qsprintf(
         $conn,
         'event.instanceOfEventPHID IS NULL');
     }
 
     if ($this->instanceSequencePairs !== null) {
       $sql = array();
 
       foreach ($this->instanceSequencePairs as $pair) {
         $sql[] = qsprintf(
           $conn,
           '(event.instanceOfEventPHID = %s AND event.sequenceIndex = %d)',
           $pair[0],
           $pair[1]);
       }
 
       $where[] = qsprintf(
         $conn,
         '%Q',
         implode(' OR ', $sql));
     }
 
     if ($this->isStub !== null) {
       $where[] = qsprintf(
         $conn,
         'event.isStub = %d',
         (int)$this->isStub);
     }
 
     return $where;
   }
 
   protected function getPrimaryTableAlias() {
     return 'event';
   }
 
   protected function shouldGroupQueryResultRows() {
     if ($this->inviteePHIDs !== null) {
       return true;
     }
     return parent::shouldGroupQueryResultRows();
   }
 
   protected function getApplicationSearchObjectPHIDColumn() {
     return 'event.phid';
   }
 
   public function getQueryApplicationClass() {
     return 'PhabricatorCalendarApplication';
   }
 
 
   protected function willFilterPage(array $events) {
     $instance_of_event_phids = array();
     $recurring_events = array();
     $viewer = $this->getViewer();
 
     $events = $this->getEventsInRange($events);
 
     $phids = array();
 
     foreach ($events as $event) {
       $phids[] = $event->getPHID();
       $instance_of = $event->getInstanceOfEventPHID();
 
       if ($instance_of) {
         $instance_of_event_phids[] = $instance_of;
       }
     }
 
     if (count($instance_of_event_phids) > 0) {
       $recurring_events = id(new PhabricatorCalendarEventQuery())
         ->setViewer($viewer)
         ->withPHIDs($instance_of_event_phids)
         ->withEventsWithNoParent(true)
         ->execute();
 
       $recurring_events = mpull($recurring_events, null, 'getPHID');
     }
 
     if ($events) {
       $invitees = id(new PhabricatorCalendarEventInviteeQuery())
         ->setViewer($viewer)
         ->withEventPHIDs($phids)
         ->execute();
       $invitees = mgroup($invitees, 'getEventPHID');
     } else {
       $invitees = array();
     }
 
     foreach ($events as $key => $event) {
       $event_invitees = idx($invitees, $event->getPHID(), array());
       $event->attachInvitees($event_invitees);
 
       $instance_of = $event->getInstanceOfEventPHID();
       if (!$instance_of) {
         continue;
       }
       $parent = idx($recurring_events, $instance_of);
 
       // should never get here
       if (!$parent) {
         unset($events[$key]);
         continue;
       }
       $event->attachParentEvent($parent);
 
       if ($this->isCancelled !== null) {
         if ($event->getIsCancelled() != $this->isCancelled) {
           unset($events[$key]);
           continue;
         }
       }
     }
 
     $events = msort($events, 'getStartDateTimeEpoch');
 
     return $events;
   }
 
   private function getEventsInRange(array $events) {
     $range_start = $this->rangeBegin;
     $range_end = $this->rangeEnd;
 
     foreach ($events as $key => $event) {
       $event_start = $event->getStartDateTimeEpoch();
       $event_end = $event->getEndDateTimeEpoch();
 
       if ($range_start && $event_end < $range_start) {
         unset($events[$key]);
       }
 
       if ($range_end && $event_start > $range_end) {
         unset($events[$key]);
       }
     }
 
     return $events;
   }
 
+  private function getRecurrenceWindowStart(
+    PhabricatorCalendarEvent $event,
+    $generate_from) {
+
+    if (!$generate_from) {
+      return null;
+    }
+
+    return PhutilCalendarAbsoluteDateTime::newFromEpoch($generate_from);
+  }
+
+  private function getRecurrenceWindowEnd(
+    PhabricatorCalendarEvent $event,
+    $generate_until) {
+
+    $end_epochs = array();
+    if ($generate_until) {
+      $end_epochs[] = $generate_until;
+    }
+
+    $until_epoch = $event->getUntilDateTimeEpoch();
+    if ($until_epoch) {
+      $end_epochs[] = $until_epoch;
+    }
+
+    if (!$end_epochs) {
+      return null;
+    }
+
+    return PhutilCalendarAbsoluteDateTime::newFromEpoch(min($end_epochs));
+  }
+
+  private function getRecurrenceLimit(
+    PhabricatorCalendarEvent $event,
+    $raw_limit) {
+
+    return $raw_limit;
+  }
+
+
 }
diff --git a/src/applications/calendar/storage/PhabricatorCalendarEvent.php b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
index db86d3980b..060c6fe5c5 100644
--- a/src/applications/calendar/storage/PhabricatorCalendarEvent.php
+++ b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
@@ -1,1045 +1,1062 @@
 <?php
 
 final class PhabricatorCalendarEvent extends PhabricatorCalendarDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorProjectInterface,
     PhabricatorMarkupInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorSubscribableInterface,
     PhabricatorTokenReceiverInterface,
     PhabricatorDestructibleInterface,
     PhabricatorMentionableInterface,
     PhabricatorFlaggableInterface,
     PhabricatorSpacesInterface,
     PhabricatorFulltextInterface,
     PhabricatorConduitResultInterface {
 
   protected $name;
   protected $hostPHID;
   protected $description;
   protected $isCancelled;
   protected $isAllDay;
   protected $icon;
   protected $mailKey;
   protected $isStub;
 
   protected $isRecurring = 0;
   protected $recurrenceFrequency = array();
 
   private $isGhostEvent = false;
   protected $instanceOfEventPHID;
   protected $sequenceIndex;
 
   protected $viewPolicy;
   protected $editPolicy;
 
   protected $spacePHID;
 
   protected $utcInitialEpoch;
   protected $utcUntilEpoch;
   protected $utcInstanceEpoch;
   protected $parameters = array();
 
   private $parentEvent = self::ATTACHABLE;
   private $invitees = self::ATTACHABLE;
 
   private $viewerTimezone;
 
   // TODO: DEPRECATED. Remove once we're sure the migrations worked.
   protected $allDayDateFrom;
   protected $allDayDateTo;
   protected $dateFrom;
   protected $dateTo;
   protected $recurrenceEndDate;
 
   // Frequency Constants
   const FREQUENCY_DAILY = 'daily';
   const FREQUENCY_WEEKLY = 'weekly';
   const FREQUENCY_MONTHLY = 'monthly';
   const FREQUENCY_YEARLY = 'yearly';
 
   public static function initializeNewCalendarEvent(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorCalendarApplication'))
       ->executeOne();
 
     $view_default = PhabricatorCalendarEventDefaultViewCapability::CAPABILITY;
     $edit_default = PhabricatorCalendarEventDefaultEditCapability::CAPABILITY;
     $view_policy = $app->getPolicy($view_default);
     $edit_policy = $app->getPolicy($edit_default);
 
     $now = PhabricatorTime::getNow();
 
     $default_icon = 'fa-calendar';
 
     $datetime_start = PhutilCalendarAbsoluteDateTime::newFromEpoch(
       $now,
       $actor->getTimezoneIdentifier());
     $datetime_end = $datetime_start->newRelativeDateTime('PT1H');
 
     return id(new PhabricatorCalendarEvent())
       ->setHostPHID($actor->getPHID())
       ->setIsCancelled(0)
       ->setIsAllDay(0)
       ->setIsStub(0)
       ->setIsRecurring(0)
       ->setRecurrenceFrequency(
         array(
           'rule' => self::FREQUENCY_WEEKLY,
         ))
       ->setIcon($default_icon)
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy)
       ->setSpacePHID($actor->getDefaultSpacePHID())
       ->attachInvitees(array())
       ->setDateFrom(0)
       ->setDateTo(0)
       ->setAllDayDateFrom(0)
       ->setAllDayDateTo(0)
       ->setStartDateTime($datetime_start)
       ->setEndDateTime($datetime_end)
       ->applyViewerTimezone($actor);
   }
 
-  private function newChild(PhabricatorUser $actor, $sequence) {
+  private function newChild(
+    PhabricatorUser $actor,
+    $sequence,
+    PhutilCalendarDateTime $start = null) {
     if (!$this->isParentEvent()) {
       throw new Exception(
         pht(
           'Unable to generate a new child event for an event which is not '.
           'a recurring parent event!'));
     }
 
     $child = id(new self())
       ->setIsCancelled(0)
       ->setIsStub(0)
       ->setInstanceOfEventPHID($this->getPHID())
       ->setSequenceIndex($sequence)
       ->setIsRecurring(true)
       ->setRecurrenceFrequency($this->getRecurrenceFrequency())
       ->attachParentEvent($this)
       ->setAllDayDateFrom(0)
       ->setAllDayDateTo(0)
       ->setDateFrom(0)
       ->setDateTo(0);
 
-    return $child->copyFromParent($actor);
+    return $child->copyFromParent($actor, $start);
   }
 
   protected function readField($field) {
     static $inherit = array(
       'hostPHID' => true,
       'isAllDay' => true,
       'icon' => true,
       'spacePHID' => true,
       'viewPolicy' => true,
       'editPolicy' => true,
       'name' => true,
       'description' => true,
     );
 
     // Read these fields from the parent event instead of this event. For
     // example, we want any changes to the parent event's name to apply to
     // the child.
     if (isset($inherit[$field])) {
       if ($this->getIsStub()) {
         // TODO: This should be unconditional, but the execution order of
         // CalendarEventQuery and applyViewerTimezone() are currently odd.
         if ($this->parentEvent !== self::ATTACHABLE) {
           return $this->getParentEvent()->readField($field);
         }
       }
     }
 
     return parent::readField($field);
   }
 
 
-  public function copyFromParent(PhabricatorUser $actor) {
+  public function copyFromParent(
+    PhabricatorUser $actor,
+    PhutilCalendarDateTime $start = null) {
+
     if (!$this->isChildEvent()) {
       throw new Exception(
         pht(
           'Unable to copy from parent event: this is not a child event.'));
     }
 
     $parent = $this->getParentEvent();
 
     $this
       ->setHostPHID($parent->getHostPHID())
       ->setIsAllDay($parent->getIsAllDay())
       ->setIcon($parent->getIcon())
       ->setSpacePHID($parent->getSpacePHID())
       ->setViewPolicy($parent->getViewPolicy())
       ->setEditPolicy($parent->getEditPolicy())
       ->setName($parent->getName())
       ->setDescription($parent->getDescription());
 
     $sequence = $this->getSequenceIndex();
-    $start_datetime = $parent->newSequenceIndexDateTime($sequence);
 
-    if (!$start_datetime) {
-      throw new Exception(
-        "Sequence {$sequence} does not exist for event!");
+    if ($start) {
+      $start_datetime = $start;
+    } else {
+      $start_datetime = $parent->newSequenceIndexDateTime($sequence);
+
+      if (!$start_datetime) {
+        throw new Exception(
+          pht(
+            'Sequence "%s" is not valid for event!',
+            $sequence));
+      }
     }
 
     $duration = $parent->newDuration();
     $end_datetime = $start_datetime->newRelativeDateTime($duration);
 
     $this
       ->setStartDateTime($start_datetime)
       ->setEndDateTime($end_datetime);
 
     return $this;
   }
 
   public function isValidSequenceIndex(PhabricatorUser $viewer, $sequence) {
     return (bool)$this->newSequenceIndexDateTime($sequence);
   }
 
   public function newSequenceIndexDateTime($sequence) {
     $set = $this->newRecurrenceSet();
     if (!$set) {
       return null;
     }
 
     $instances = $set->getEventsBetween(
       null,
       $this->newUntilDateTime(),
       $sequence + 1);
 
     return idx($instances, $sequence, null);
   }
 
   public function newStub(PhabricatorUser $actor, $sequence) {
     $stub = $this->newChild($actor, $sequence);
 
     $stub->setIsStub(1);
 
     $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
       $stub->save();
     unset($unguarded);
 
     $stub->applyViewerTimezone($actor);
 
     return $stub;
   }
 
-  public function newGhost(PhabricatorUser $actor, $sequence) {
-    $ghost = $this->newChild($actor, $sequence);
+  public function newGhost(
+    PhabricatorUser $actor,
+    $sequence,
+    PhutilCalendarDateTime $start = null) {
+
+    $ghost = $this->newChild($actor, $sequence, $start);
 
     $ghost
       ->setIsGhostEvent(true)
       ->makeEphemeral();
 
     $ghost->applyViewerTimezone($actor);
 
     return $ghost;
   }
 
   public function applyViewerTimezone(PhabricatorUser $viewer) {
     $this->viewerTimezone = $viewer->getTimezoneIdentifier();
     return $this;
   }
 
   public function getDuration() {
     return ($this->getEndDateTimeEpoch() - $this->getStartDateTimeEpoch());
   }
 
   public function updateUTCEpochs() {
     // The "intitial" epoch is the start time of the event, in UTC.
     $start_date = $this->newStartDateTime()
       ->setViewerTimezone('UTC');
     $start_epoch = $start_date->getEpoch();
     $this->setUTCInitialEpoch($start_epoch);
 
     // The "until" epoch is the last UTC epoch on which any instance of this
     // event occurs. For infinitely recurring events, it is `null`.
 
     if (!$this->getIsRecurring()) {
       $end_date = $this->newEndDateTime()
         ->setViewerTimezone('UTC');
       $until_epoch = $end_date->getEpoch();
     } else {
       $until_epoch = null;
       $until_date = $this->newUntilDateTime();
       if ($until_date) {
         $until_date->setViewerTimezone('UTC');
         $duration = $this->newDuration();
         $until_epoch = id(new PhutilCalendarRelativeDateTime())
           ->setOrigin($until_date)
           ->setDuration($duration)
           ->getEpoch();
       }
     }
     $this->setUTCUntilEpoch($until_epoch);
 
     // The "instance" epoch is a property of instances of recurring events.
     // It's the original UTC epoch on which the instance started. Usually that
     // is the same as the start date, but they may be different if the instance
     // has been edited.
 
     // The ICS format uses this value (original start time) to identify event
     // instances, and must do so because it allows additional arbitrary
     // instances to be added (with "RDATE").
 
     $instance_epoch = null;
     $instance_date = $this->newInstanceDateTime();
     if ($instance_date) {
       $instance_epoch = $instance_date
         ->setViewerTimezone('UTC')
         ->getEpoch();
     }
     $this->setUTCInstanceEpoch($instance_epoch);
 
     return $this;
   }
 
   public function save() {
     if (!$this->mailKey) {
       $this->mailKey = Filesystem::readRandomCharacters(20);
     }
 
     $this->updateUTCEpochs();
 
     return parent::save();
   }
 
   /**
    * Get the event start epoch for evaluating invitee availability.
    *
    * When assessing availability, we pretend events start earlier than they
    * really do. This allows us to mark users away for the entire duration of a
    * series of back-to-back meetings, even if they don't strictly overlap.
    *
    * @return int Event start date for availability caches.
    */
   public function getStartDateTimeEpochForCache() {
     $epoch = $this->getStartDateTimeEpoch();
     $window = phutil_units('15 minutes in seconds');
     return ($epoch - $window);
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_COLUMN_SCHEMA => array(
         'name' => 'text',
         'description' => 'text',
         'isCancelled' => 'bool',
         'isAllDay' => 'bool',
         'icon' => 'text32',
         'mailKey' => 'bytes20',
         'isRecurring' => 'bool',
         'instanceOfEventPHID' => 'phid?',
         'sequenceIndex' => 'uint32?',
         'isStub' => 'bool',
         'utcInitialEpoch' => 'epoch',
         'utcUntilEpoch' => 'epoch?',
         'utcInstanceEpoch' => 'epoch?',
 
         // TODO: DEPRECATED.
         'allDayDateFrom' => 'epoch',
         'allDayDateTo' => 'epoch',
         'dateFrom' => 'epoch',
         'dateTo' => 'epoch',
         'recurrenceEndDate' => 'epoch?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_date' => array(
           'columns' => array('dateFrom', 'dateTo'),
         ),
         'key_instance' => array(
           'columns' => array('instanceOfEventPHID', 'sequenceIndex'),
           'unique' => true,
         ),
         'key_epoch' => array(
           'columns' => array('utcInitialEpoch', 'utcUntilEpoch'),
         ),
         'key_rdate' => array(
           'columns' => array('instanceOfEventPHID', 'utcInstanceEpoch'),
           'unique' => true,
         ),
       ),
       self::CONFIG_SERIALIZATION => array(
         'recurrenceFrequency' => self::SERIALIZATION_JSON,
         'parameters' => self::SERIALIZATION_JSON,
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorCalendarEventPHIDType::TYPECONST);
   }
 
   public function getMonogram() {
     return 'E'.$this->getID();
   }
 
   public function getInvitees() {
     return $this->assertAttached($this->invitees);
   }
 
   public function attachInvitees(array $invitees) {
     $this->invitees = $invitees;
     return $this;
   }
 
   public function getInviteePHIDsForEdit() {
     $invitees = array();
 
     foreach ($this->getInvitees() as $invitee) {
       if ($invitee->isUninvited()) {
         continue;
       }
       $invitees[] = $invitee->getInviteePHID();
     }
 
     return $invitees;
   }
 
   public function getUserInviteStatus($phid) {
     $invitees = $this->getInvitees();
     $invitees = mpull($invitees, null, 'getInviteePHID');
 
     $invited = idx($invitees, $phid);
     if (!$invited) {
       return PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
     }
     $invited = $invited->getStatus();
     return $invited;
   }
 
   public function getIsUserAttending($phid) {
     $attending_status = PhabricatorCalendarEventInvitee::STATUS_ATTENDING;
 
     $old_status = $this->getUserInviteStatus($phid);
     $is_attending = ($old_status == $attending_status);
 
     return $is_attending;
   }
 
   public function getIsUserInvited($phid) {
     $uninvited_status = PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
     $declined_status = PhabricatorCalendarEventInvitee::STATUS_DECLINED;
     $status = $this->getUserInviteStatus($phid);
     if ($status == $uninvited_status || $status == $declined_status) {
       return false;
     }
     return true;
   }
 
   public function getIsGhostEvent() {
     return $this->isGhostEvent;
   }
 
   public function setIsGhostEvent($is_ghost_event) {
     $this->isGhostEvent = $is_ghost_event;
     return $this;
   }
 
   public function getFrequencyRule() {
     return idx($this->recurrenceFrequency, 'rule');
   }
 
   public function getFrequencyUnit() {
     $frequency = $this->getFrequencyRule();
 
     switch ($frequency) {
       case 'daily':
         return 'day';
       case 'weekly':
         return 'week';
       case 'monthly':
         return 'month';
       case 'yearly':
         return 'year';
       default:
         return 'day';
     }
   }
 
   public function getURI() {
     if ($this->getIsGhostEvent()) {
       $base = $this->getParentEvent()->getURI();
       $sequence = $this->getSequenceIndex();
       return "{$base}/{$sequence}/";
     }
 
     return '/'.$this->getMonogram();
   }
 
   public function getParentEvent() {
     return $this->assertAttached($this->parentEvent);
   }
 
   public function attachParentEvent($event) {
     $this->parentEvent = $event;
     return $this;
   }
 
   public function isParentEvent() {
     return ($this->getIsRecurring() && !$this->getInstanceOfEventPHID());
   }
 
   public function isChildEvent() {
     return ($this->instanceOfEventPHID !== null);
   }
 
   public function isCancelledEvent() {
     if ($this->getIsCancelled()) {
       return true;
     }
 
     if ($this->isChildEvent()) {
       if ($this->getParentEvent()->getIsCancelled()) {
         return true;
       }
     }
 
     return false;
   }
 
   public function renderEventDate(
     PhabricatorUser $viewer,
     $show_end) {
 
     $start = $this->newStartDateTime();
     $end = $this->newEndDateTime();
 
     if ($show_end) {
       $min_date = $start->newPHPDateTime();
       $max_date = $end->newPHPDateTime();
 
       $min_day = $min_date->format('Y m d');
       $max_day = $max_date->format('Y m d');
 
       $show_end_date = ($min_day != $max_day);
     } else {
       $show_end_date = false;
     }
 
     $min_epoch = $start->getEpoch();
     $max_epoch = $end->getEpoch();
 
     if ($this->getIsAllDay()) {
       if ($show_end_date) {
         return pht(
           '%s - %s, All Day',
           phabricator_date($min_epoch, $viewer),
           phabricator_date($max_epoch, $viewer));
       } else {
         return pht(
           '%s, All Day',
           phabricator_date($min_epoch, $viewer));
       }
     } else if ($show_end_date) {
       return pht(
         '%s - %s',
         phabricator_datetime($min_epoch, $viewer),
         phabricator_datetime($max_epoch, $viewer));
     } else if ($show_end) {
       return pht(
         '%s - %s',
         phabricator_datetime($min_epoch, $viewer),
         phabricator_time($max_epoch, $viewer));
     } else {
       return pht(
         '%s',
         phabricator_datetime($min_epoch, $viewer));
     }
   }
 
 
   public function getDisplayIcon(PhabricatorUser $viewer) {
     if ($this->isCancelledEvent()) {
       return 'fa-times';
     }
 
     if ($viewer->isLoggedIn()) {
       $status = $this->getUserInviteStatus($viewer->getPHID());
       switch ($status) {
         case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
           return 'fa-check-circle';
         case PhabricatorCalendarEventInvitee::STATUS_INVITED:
           return 'fa-user-plus';
         case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
           return 'fa-times';
       }
     }
 
     return $this->getIcon();
   }
 
   public function getDisplayIconColor(PhabricatorUser $viewer) {
     if ($this->isCancelledEvent()) {
       return 'red';
     }
 
     if ($viewer->isLoggedIn()) {
       $status = $this->getUserInviteStatus($viewer->getPHID());
       switch ($status) {
         case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
           return 'green';
         case PhabricatorCalendarEventInvitee::STATUS_INVITED:
           return 'green';
         case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
           return 'grey';
       }
     }
 
     return 'bluegrey';
   }
 
   public function getDisplayIconLabel(PhabricatorUser $viewer) {
     if ($this->isCancelledEvent()) {
       return pht('Cancelled');
     }
 
     if ($viewer->isLoggedIn()) {
       $status = $this->getUserInviteStatus($viewer->getPHID());
       switch ($status) {
         case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
           return pht('Attending');
         case PhabricatorCalendarEventInvitee::STATUS_INVITED:
           return pht('Invited');
         case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
           return pht('Declined');
       }
     }
 
     return null;
   }
 
   public function getICSFilename() {
     return $this->getMonogram().'.ics';
   }
 
   public function newIntermediateEventNode(PhabricatorUser $viewer) {
     $base_uri = new PhutilURI(PhabricatorEnv::getProductionURI('/'));
     $domain = $base_uri->getDomain();
 
     $uid = $this->getPHID().'@'.$domain;
 
     $created = $this->getDateCreated();
     $created = PhutilCalendarAbsoluteDateTime::newFromEpoch($created);
 
     $modified = $this->getDateModified();
     $modified = PhutilCalendarAbsoluteDateTime::newFromEpoch($modified);
 
     $date_start = $this->newStartDateTime();
     $date_end = $this->newEndDateTime();
 
     if ($this->getIsAllDay()) {
       $date_start->setIsAllDay(true);
       $date_end->setIsAllDay(true);
     }
 
     $host_phid = $this->getHostPHID();
 
     $invitees = $this->getInvitees();
     foreach ($invitees as $key => $invitee) {
       if ($invitee->isUninvited()) {
         unset($invitees[$key]);
       }
     }
 
     $phids = array();
     $phids[] = $host_phid;
     foreach ($invitees as $invitee) {
       $phids[] = $invitee->getInviteePHID();
     }
 
     $handles = $viewer->loadHandles($phids);
 
     $host_handle = $handles[$host_phid];
     $host_name = $host_handle->getFullName();
     $host_uri = $host_handle->getURI();
     $host_uri = PhabricatorEnv::getURI($host_uri);
 
     $organizer = id(new PhutilCalendarUserNode())
       ->setName($host_name)
       ->setURI($host_uri);
 
     $attendees = array();
     foreach ($invitees as $invitee) {
       $invitee_phid = $invitee->getInviteePHID();
       $invitee_handle = $handles[$invitee_phid];
       $invitee_name = $invitee_handle->getFullName();
       $invitee_uri = $invitee_handle->getURI();
       $invitee_uri = PhabricatorEnv::getURI($invitee_uri);
 
       switch ($invitee->getStatus()) {
         case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
           $status = PhutilCalendarUserNode::STATUS_ACCEPTED;
           break;
         case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
           $status = PhutilCalendarUserNode::STATUS_DECLINED;
           break;
         case PhabricatorCalendarEventInvitee::STATUS_INVITED:
         default:
           $status = PhutilCalendarUserNode::STATUS_INVITED;
           break;
       }
 
       $attendees[] = id(new PhutilCalendarUserNode())
         ->setName($invitee_name)
         ->setURI($invitee_uri)
         ->setStatus($status);
     }
 
     $node = id(new PhutilCalendarEventNode())
       ->setUID($uid)
       ->setName($this->getName())
       ->setDescription($this->getDescription())
       ->setCreatedDateTime($created)
       ->setModifiedDateTime($modified)
       ->setStartDateTime($date_start)
       ->setEndDateTime($date_end)
       ->setOrganizer($organizer)
       ->setAttendees($attendees);
 
     return $node;
   }
 
   public function newStartDateTime() {
     $datetime = $this->getParameter('startDateTime');
     if ($datetime) {
       return $this->newDateTimeFromDictionary($datetime);
     }
 
     $epoch = $this->getDateFrom();
     return $this->newDateTimeFromEpoch($epoch);
   }
 
   public function getStartDateTimeEpoch() {
     return $this->newStartDateTime()->getEpoch();
   }
 
   public function newEndDateTime() {
     $datetime = $this->getParameter('endDateTime');
     if ($datetime) {
       return $this->newDateTimeFromDictionary($datetime);
     }
 
     $epoch = $this->getDateTo();
     return $this->newDateTimeFromEpoch($epoch);
   }
 
   public function getEndDateTimeEpoch() {
     return $this->newEndDateTime()->getEpoch();
   }
 
   public function newUntilDateTime() {
     $datetime = $this->getParameter('untilDateTime');
     if ($datetime) {
       return $this->newDateTimeFromDictionary($datetime);
     }
 
     $epoch = $this->getRecurrenceEndDate();
     if (!$epoch) {
       return null;
     }
     return $this->newDateTimeFromEpoch($epoch);
   }
 
   public function getUntilDateTimeEpoch() {
     $datetime = $this->newUntilDateTime();
 
     if (!$datetime) {
       return null;
     }
 
     return $datetime->getEpoch();
   }
 
   public function newDuration() {
     return id(new PhutilCalendarDuration())
       ->setSeconds($this->getDuration());
   }
 
   public function newInstanceDateTime() {
     if (!$this->getIsRecurring()) {
       return null;
     }
 
     $index = $this->getSequenceIndex();
     if (!$index) {
       return null;
     }
 
     return $this->newSequenceIndexDateTime($index);
   }
 
   private function newDateTimeFromEpoch($epoch) {
     $datetime = PhutilCalendarAbsoluteDateTime::newFromEpoch($epoch);
 
     if ($this->getIsAllDay()) {
       $datetime->setIsAllDay(true);
     }
 
     return $this->newDateTimeFromDateTime($datetime);
   }
 
   private function newDateTimeFromDictionary(array $dict) {
     $datetime = PhutilCalendarAbsoluteDateTime::newFromDictionary($dict);
     return $this->newDateTimeFromDateTime($datetime);
   }
 
   private function newDateTimeFromDateTime(PhutilCalendarDateTime $datetime) {
     $viewer_timezone = $this->viewerTimezone;
     if ($viewer_timezone) {
       $datetime->setViewerTimezone($viewer_timezone);
     }
 
     return $datetime;
   }
 
   public function getParameter($key, $default = null) {
     return idx($this->parameters, $key, $default);
   }
 
   public function setParameter($key, $value) {
     $this->parameters[$key] = $value;
     return $this;
   }
 
   public function setStartDateTime(PhutilCalendarDateTime $datetime) {
     return $this->setParameter(
       'startDateTime',
       $datetime->newAbsoluteDateTime()->toDictionary());
   }
 
   public function setEndDateTime(PhutilCalendarDateTime $datetime) {
     return $this->setParameter(
       'endDateTime',
       $datetime->newAbsoluteDateTime()->toDictionary());
   }
 
   public function setUntilDateTime(PhutilCalendarDateTime $datetime) {
     return $this->setParameter(
       'untilDateTime',
       $datetime->newAbsoluteDateTime()->toDictionary());
   }
 
 
   public function newRecurrenceRule() {
     if ($this->isChildEvent()) {
       return $this->getParentEvent()->newRecurrenceRule();
     }
 
     // TODO: This is a little fragile since it relies on the convenient
     // definition of FREQUENCY constants here and in RecurrenceRule, but
     // should be gone soon.
     $map = array(
       'FREQ' => phutil_utf8_strtoupper($this->getFrequencyRule()),
     );
 
     $rrule = PhutilCalendarRecurrenceRule::newFromDictionary($map);
 
     $start = $this->newStartDateTime();
     $rrule->setStartDateTime($start);
 
     return $rrule;
   }
 
   public function newRecurrenceSet() {
     if ($this->isChildEvent()) {
       return $this->getParentEvent()->newRecurrenceSet();
     }
 
     $set = new PhutilCalendarRecurrenceSet();
 
     $rrule = $this->newRecurrenceRule();
     $set->addSource($rrule);
 
     return $set;
   }
 
 /* -(  Markup Interface  )--------------------------------------------------- */
 
 
   /**
    * @task markup
    */
   public function getMarkupFieldKey($field) {
     $hash = PhabricatorHash::digest($this->getMarkupText($field));
     $id = $this->getID();
     return "calendar:T{$id}:{$field}:{$hash}";
   }
 
 
   /**
    * @task markup
    */
   public function getMarkupText($field) {
     return $this->getDescription();
   }
 
 
   /**
    * @task markup
    */
   public function newMarkupEngine($field) {
     return PhabricatorMarkupEngine::newCalendarMarkupEngine();
   }
 
 
   /**
    * @task markup
    */
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
     return $output;
   }
 
 
   /**
    * @task markup
    */
   public function shouldUseMarkupCache($field) {
     return (bool)$this->getID();
   }
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     // The host of an event can always view and edit it.
     $user_phid = $this->getHostPHID();
     if ($user_phid) {
       $viewer_phid = $viewer->getPHID();
       if ($viewer_phid == $user_phid) {
         return true;
       }
     }
 
     if ($capability == PhabricatorPolicyCapability::CAN_VIEW) {
       $status = $this->getUserInviteStatus($viewer->getPHID());
       if ($status == PhabricatorCalendarEventInvitee::STATUS_INVITED ||
         $status == PhabricatorCalendarEventInvitee::STATUS_ATTENDING ||
         $status == PhabricatorCalendarEventInvitee::STATUS_DECLINED) {
         return true;
       }
     }
 
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return pht(
       'The host of an event can always view and edit it. Users who are '.
       'invited to an event can always view it.');
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new PhabricatorCalendarEventEditor();
   }
 
   public function getApplicationTransactionObject() {
     return $this;
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhabricatorCalendarEventTransaction();
   }
 
   public function willRenderTimeline(
     PhabricatorApplicationTransactionView $timeline,
     AphrontRequest $request) {
 
     return $timeline;
   }
 
 /* -(  PhabricatorSubscribableInterface  )----------------------------------- */
 
 
   public function isAutomaticallySubscribed($phid) {
     return ($phid == $this->getHostPHID());
   }
 
 /* -(  PhabricatorTokenReceiverInterface  )---------------------------------- */
 
 
   public function getUsersToNotifyOfTokenGiven() {
     return array($this->getHostPHID());
   }
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
     $this->delete();
     $this->saveTransaction();
   }
 
 /* -(  PhabricatorSpacesInterface  )----------------------------------------- */
 
 
   public function getSpacePHID() {
     return $this->spacePHID;
   }
 
 
 /* -(  PhabricatorFulltextInterface  )--------------------------------------- */
 
 
   public function newFulltextEngine() {
     return new PhabricatorCalendarEventFulltextEngine();
   }
 
 
 /* -(  PhabricatorConduitResultInterface  )---------------------------------- */
 
 
   public function getFieldSpecificationsForConduit() {
     return array(
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('name')
         ->setType('string')
         ->setDescription(pht('The name of the event.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('description')
         ->setType('string')
         ->setDescription(pht('The event description.')),
     );
   }
 
   public function getFieldValuesForConduit() {
     return array(
       'name' => $this->getName(),
       'description' => $this->getDescription(),
     );
   }
 
   public function getConduitSearchAttachments() {
     return array();
   }
 
 }