function doElongate(polyhedron: Polyhedron, twist?: Twist) {
  const caps = Cap.getAll(polyhedron);
  const boundary = caps[0].boundary();
  const n = boundary.numSides;
  const duplicated = duplicateVertices(polyhedron, boundary, twist);
  let vertexSets: VertexList[];
  let multiplier: number;

  const duplicatedCaps = Cap.getAll(duplicated);
  if (duplicatedCaps.length === 2) {
    vertexSets = duplicatedCaps;
    multiplier = 1 / 2;
  } else {
    // Otherwise it's the largest face
    vertexSets = [boundary.adjacentFaces()[0].withPolyhedron(duplicated)];
    multiplier = 1;
  }
  const adjustInfo = { vertexSets, boundary, multiplier };

  const height = polyhedron.edgeLength() * (twist ? antiprismHeight(n) : 1);

  const endVertices = getScaledPrismVertices(adjustInfo, height, twist);
  return {
    animationData: {
      start: duplicated,
      endVertices,
    },
  };
}

export function getCupolaGyrate(polyhedron: Polyhedron, cap: Cap) {
  const isOrtho = _.every(cap.boundary().edges, edge => {
    const [n1, n2] = _.map(edge.adjacentFaces(), 'numSides');
    return (n1 === 4) === (n2 === 4);
  });
  return isOrtho ? 'ortho' : 'gyro';
}

function getOppositeCaps(polyhedron: Polyhedron) {
  const caps = Cap.getAll(polyhedron);
  for (let cap of caps) {
    const cap2 = _.find(caps, cap2 => isInverse(cap.normal(), cap2.normal()));
    if (cap2) return [cap, cap2];
  }
  return undefined;
}

// Return true if the base and augmentee are aligned
function isAligned(
  polyhedron: Polyhedron,
  base: Face,
  underside: Face,
  gyrate: string | undefined,
  augmentType: string,
) {
  if (augmentType === 'pyramid') return true;
  const baseType = getBaseType(base);
  if (baseType === 'pyramid' || baseType === 'antiprism') {
    return true;
  }

  if (baseType === 'prism' && Cap.getAll(polyhedron).length === 0) {
    return true;
  }

  if (baseType !== 'truncated' && _.isNil(gyrate)) {
    throw new Error(`Must define 'gyrate' for augmenting ${baseType} `);
  }

  const adjFace =
    baseType === 'prism' ? getOppositePrismFace(base) : base.adjacentFaces()[0];
  const alignedFace = getCyclic(underside.adjacentFaces(), -1);

  if (baseType === 'rhombicosidodecahedron') {
    const isOrtho = (adjFace.numSides !== 4) === (alignedFace.numSides !== 4);
    return isOrtho === (gyrate === 'ortho');
  }

  // It's orthogonal if triangle faces are aligned or non-triangle faces are aligned
  const isOrtho = (adjFace.numSides !== 3) === (alignedFace.numSides !== 3);

  if (baseType === 'truncated') {
    return !isOrtho;
  }

  // "ortho" or "gyro" is actually determined by whether the *tops* are aligned, not the bottoms
  // So for a cupola-rotunda, it's actually the opposite of everything else
  if (isCupolaRotunda(Cap.getAll(polyhedron)[0].type, augmentType)) {
    return isOrtho !== (gyrate === 'ortho');
  }

  return isOrtho === (gyrate === 'ortho');
}

export function getCapAlignment(polyhedron: Polyhedron, cap: Cap) {
  const isRhombicosidodecahedron = cap.type === 'cupola';
  const orthoCaps = isRhombicosidodecahedron
    ? _.filter(
        Cap.getAll(polyhedron),
        cap => getCupolaGyrate(polyhedron, cap) === 'ortho',
      )
    : [];

  const otherNormal =
    orthoCaps.length > 0
      ? getSingle(orthoCaps)
          .boundary()
          .normal()
      : polyhedron.largestFace().normal();

  return isInverse(cap.normal(), otherNormal) ? 'para' : 'meta';
}

export function getChirality(polyhedron: Polyhedron) {
  const [cap1, cap2] = Cap.getAll(polyhedron);
  const boundary = cap1.boundary();
  const isCupolaRotunda = cap1.type !== cap2.type;

  const nonTriangleFace = find(boundary.edges, e => e.face.numSides !== 3);
  const rightFaceAcross = nonTriangleFace
    .twin()
    .prev()
    .twin()
    .next()
    .twin().face;
  // I'm pretty sure this is the same logic as in augment
  if (isCupolaRotunda) {
    return rightFaceAcross.numSides !== 3 ? 'right' : 'left';
  }
  return rightFaceAcross.numSides !== 3 ? 'left' : 'right';
}

      options.direction = getGyrateDirection(polyhedron, cap);
      if (
        _.filter(
          relations,
          relation =>
            relation.direction === options.direction && !!relation.align,
        ).length > 1
      ) {
        options.align = getCapAlignment(polyhedron, cap);
      }
    }
    return options;
  },

  allOptionCombos(polyhedron) {
    return Cap.getAll(polyhedron).map(cap => ({ cap }));
  },

  hitOption: 'cap',
  getHitOption(polyhedron, hitPnt) {
    const cap = Cap.find(polyhedron, hitPnt);
    return cap ? { cap } : {};
  },

  faceSelectionStates(polyhedron, { cap }) {
    const allCapFaces = _.flatMap(Cap.getAll(polyhedron), cap => cap.faces());
    return _.map(polyhedron.faces, face => {
      if (_.isObject(cap) && face.inSet(cap.faces())) return 'selected';
      if (face.inSet(allCapFaces)) return 'selectable';
    });
  },

function getAugmentAlignment(polyhedron: Polyhedron, face: Face) {
  const boundary = getSingle(Cap.getAll(polyhedron)).boundary();
  return isInverse(boundary.normal(), face.normal()) ? 'para' : 'meta';
}

 polyhedron.withChanges(solid =>
   solid.withoutFaces(cap.faces()).addFaces([cap.boundary().vertices]),