diff --git a/native/chat/chat-input-bar.react.js b/native/chat/chat-input-bar.react.js
index 79762dcf5..45ea46474 100644
--- a/native/chat/chat-input-bar.react.js
+++ b/native/chat/chat-input-bar.react.js
@@ -1,986 +1,986 @@
 // @flow
 
 import invariant from 'invariant';
 import _throttle from 'lodash/throttle';
 import * as React from 'react';
 import {
   View,
   TextInput,
   TouchableOpacity,
   Platform,
   Text,
   ActivityIndicator,
   TouchableWithoutFeedback,
   NativeAppEventEmitter,
 } from 'react-native';
 import { TextInputKeyboardMangerIOS } from 'react-native-keyboard-input';
 import Animated, { EasingNode } from 'react-native-reanimated';
 import Icon from 'react-native-vector-icons/Ionicons';
 import { useDispatch } from 'react-redux';
 
 import {
   joinThreadActionTypes,
   joinThread,
   newThreadActionTypes,
 } from 'lib/actions/thread-actions';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors';
 import { localIDPrefix, trimMessage } from 'lib/shared/message-utils';
 import {
   threadHasPermission,
   viewerIsMember,
   threadFrozenDueToViewerBlock,
   threadActualMembers,
   checkIfDefaultMembersAreVoiced,
   draftKeyFromThreadID,
 } from 'lib/shared/thread-utils';
 import type { CalendarQuery } from 'lib/types/entry-types';
 import type { LoadingStatus } from 'lib/types/loading-types';
 import type { PhotoPaste } from 'lib/types/media-types';
 import { messageTypes } from 'lib/types/message-types';
 import type { Dispatch } from 'lib/types/redux-types';
 import {
   type ThreadInfo,
   threadPermissions,
   type ClientThreadJoinRequest,
   type ThreadJoinPayload,
 } from 'lib/types/thread-types';
 import { type UserInfos } from 'lib/types/user-types';
 import {
   type DispatchActionPromise,
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils';
 
 import Button from '../components/button.react';
 import ClearableTextInput from '../components/clearable-text-input.react';
 import SWMansionIcon from '../components/swmansion-icon.react';
 import { type UpdateDraft, type MoveDraft, useDrafts } from '../data/core-data';
 import { type InputState, InputStateContext } from '../input/input-state';
 import { getKeyboardHeight } from '../keyboard/keyboard';
 import KeyboardInputHost from '../keyboard/keyboard-input-host.react';
 import {
   type KeyboardState,
   KeyboardContext,
 } from '../keyboard/keyboard-state';
 import {
   nonThreadCalendarQuery,
   activeThreadSelector,
 } from '../navigation/nav-selectors';
 import { NavContext } from '../navigation/navigation-context';
 import {
   type NavigationRoute,
   CameraModalRouteName,
   ImagePasteModalRouteName,
 } from '../navigation/route-names';
 import { useSelector } from '../redux/redux-utils';
 import { type Colors, useStyles, useColors } from '../themes/colors';
 import type { LayoutEvent } from '../types/react-native';
 import { type AnimatedViewStyle, AnimatedView } from '../types/styles';
 import { runTiming } from '../utils/animation-utils';
 import { ChatContext } from './chat-context';
 import type { ChatNavigationProp } from './chat.react';
 
 /* eslint-disable import/no-named-as-default-member */
 const {
   Value,
   Clock,
   block,
   set,
   cond,
   neq,
   sub,
   interpolateNode,
   stopClock,
 } = Animated;
 /* eslint-enable import/no-named-as-default-member */
 
 const expandoButtonsAnimationConfig = {
   duration: 150,
   easing: EasingNode.inOut(EasingNode.ease),
 };
 const sendButtonAnimationConfig = {
   duration: 150,
   easing: EasingNode.inOut(EasingNode.ease),
 };
 
 type BaseProps = {
   +threadInfo: ThreadInfo,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +viewerID: ?string,
   +draft: string,
   +updateDraft: UpdateDraft,
   +moveDraft: MoveDraft,
   +joinThreadLoadingStatus: LoadingStatus,
   +threadCreationInProgress: boolean,
   +calendarQuery: () => CalendarQuery,
   +nextLocalID: number,
   +userInfos: UserInfos,
   +colors: Colors,
   +styles: typeof unboundStyles,
   +onInputBarLayout?: (event: LayoutEvent) => mixed,
   +openCamera: () => mixed,
   // connectNav
   +isActive: boolean,
   // withKeyboardState
   +keyboardState: ?KeyboardState,
   // Redux dispatch functions
   +dispatch: Dispatch,
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +joinThread: (request: ClientThreadJoinRequest) => Promise<ThreadJoinPayload>,
   // withInputState
   +inputState: ?InputState,
 };
 type State = {
   +text: string,
   +textEdited: boolean,
   +buttonsExpanded: boolean,
 };
 class ChatInputBar extends React.PureComponent<Props, State> {
   textInput: ?React.ElementRef<typeof TextInput>;
   clearableTextInput: ?ClearableTextInput;
 
   expandoButtonsOpen: Value;
   targetExpandoButtonsOpen: Value;
   expandoButtonsStyle: AnimatedViewStyle;
   cameraRollIconStyle: AnimatedViewStyle;
   cameraIconStyle: AnimatedViewStyle;
   expandIconStyle: AnimatedViewStyle;
 
   sendButtonContainerOpen: Value;
   targetSendButtonContainerOpen: Value;
   sendButtonContainerStyle: AnimatedViewStyle;
 
   constructor(props: Props) {
     super(props);
     this.state = {
       text: props.draft,
       textEdited: false,
       buttonsExpanded: true,
     };
 
     this.setUpActionIconAnimations();
     this.setUpSendIconAnimations();
   }
 
   setUpActionIconAnimations() {
     this.expandoButtonsOpen = new Value(1);
     this.targetExpandoButtonsOpen = new Value(1);
     const prevTargetExpandoButtonsOpen = new Value(1);
     const expandoButtonClock = new Clock();
     const expandoButtonsOpen = block([
       cond(neq(this.targetExpandoButtonsOpen, prevTargetExpandoButtonsOpen), [
         stopClock(expandoButtonClock),
         set(prevTargetExpandoButtonsOpen, this.targetExpandoButtonsOpen),
       ]),
       cond(
         neq(this.expandoButtonsOpen, this.targetExpandoButtonsOpen),
         set(
           this.expandoButtonsOpen,
           runTiming(
             expandoButtonClock,
             this.expandoButtonsOpen,
             this.targetExpandoButtonsOpen,
             true,
             expandoButtonsAnimationConfig,
           ),
         ),
       ),
       this.expandoButtonsOpen,
     ]);
 
     this.cameraRollIconStyle = {
       ...unboundStyles.cameraRollIcon,
       opacity: expandoButtonsOpen,
     };
     this.cameraIconStyle = {
       ...unboundStyles.cameraIcon,
       opacity: expandoButtonsOpen,
     };
 
     const expandoButtonsWidth = interpolateNode(expandoButtonsOpen, {
       inputRange: [0, 1],
       outputRange: [26, 66],
     });
     this.expandoButtonsStyle = {
       ...unboundStyles.expandoButtons,
       width: expandoButtonsWidth,
     };
 
     const expandOpacity = sub(1, expandoButtonsOpen);
     this.expandIconStyle = {
       ...unboundStyles.expandIcon,
       opacity: expandOpacity,
     };
   }
 
   setUpSendIconAnimations() {
     const initialSendButtonContainerOpen = trimMessage(this.props.draft)
       ? 1
       : 0;
     this.sendButtonContainerOpen = new Value(initialSendButtonContainerOpen);
     this.targetSendButtonContainerOpen = new Value(
       initialSendButtonContainerOpen,
     );
     const prevTargetSendButtonContainerOpen = new Value(
       initialSendButtonContainerOpen,
     );
     const sendButtonClock = new Clock();
     const sendButtonContainerOpen = block([
       cond(
         neq(
           this.targetSendButtonContainerOpen,
           prevTargetSendButtonContainerOpen,
         ),
         [
           stopClock(sendButtonClock),
           set(
             prevTargetSendButtonContainerOpen,
             this.targetSendButtonContainerOpen,
           ),
         ],
       ),
       cond(
         neq(this.sendButtonContainerOpen, this.targetSendButtonContainerOpen),
         set(
           this.sendButtonContainerOpen,
           runTiming(
             sendButtonClock,
             this.sendButtonContainerOpen,
             this.targetSendButtonContainerOpen,
             true,
             sendButtonAnimationConfig,
           ),
         ),
       ),
       this.sendButtonContainerOpen,
     ]);
 
     const sendButtonContainerWidth = interpolateNode(sendButtonContainerOpen, {
       inputRange: [0, 1],
       outputRange: [4, 38],
     });
     this.sendButtonContainerStyle = { width: sendButtonContainerWidth };
   }
 
   static mediaGalleryOpen(props: Props) {
     const { keyboardState } = props;
     return !!(keyboardState && keyboardState.mediaGalleryOpen);
   }
 
   static systemKeyboardShowing(props: Props) {
     const { keyboardState } = props;
     return !!(keyboardState && keyboardState.systemKeyboardShowing);
   }
 
   get systemKeyboardShowing() {
     return ChatInputBar.systemKeyboardShowing(this.props);
   }
 
   immediatelyShowSendButton() {
     this.sendButtonContainerOpen.setValue(1);
     this.targetSendButtonContainerOpen.setValue(1);
   }
 
   updateSendButton(currentText: string) {
     if (this.shouldShowTextInput) {
       this.targetSendButtonContainerOpen.setValue(currentText === '' ? 0 : 1);
     } else {
       this.setUpSendIconAnimations();
     }
   }
 
   componentDidMount() {
     if (this.props.isActive) {
       this.addReplyListener();
     }
   }
 
   componentWillUnmount() {
     if (this.props.isActive) {
       this.removeReplyListener();
     }
   }
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     if (
       this.state.textEdited &&
       this.state.text &&
       this.props.threadInfo.id !== prevProps.threadInfo.id
     ) {
       this.props.moveDraft(
         draftKeyFromThreadID(prevProps.threadInfo.id),
         draftKeyFromThreadID(this.props.threadInfo.id),
       );
     } else if (!this.state.textEdited && this.props.draft !== prevProps.draft) {
       this.setState({ text: this.props.draft });
     }
     if (this.props.isActive && !prevProps.isActive) {
       this.addReplyListener();
     } else if (!this.props.isActive && prevProps.isActive) {
       this.removeReplyListener();
     }
 
     const currentText = trimMessage(this.state.text);
     const prevText = trimMessage(prevState.text);
 
     if (
       (currentText === '' && prevText !== '') ||
       (currentText !== '' && prevText === '')
     ) {
       this.updateSendButton(currentText);
     }
 
     const systemKeyboardIsShowing = ChatInputBar.systemKeyboardShowing(
       this.props,
     );
     const systemKeyboardWasShowing = ChatInputBar.systemKeyboardShowing(
       prevProps,
     );
     if (systemKeyboardIsShowing && !systemKeyboardWasShowing) {
       this.hideButtons();
     } else if (!systemKeyboardIsShowing && systemKeyboardWasShowing) {
       this.expandButtons();
     }
 
     const imageGalleryIsOpen = ChatInputBar.mediaGalleryOpen(this.props);
     const imageGalleryWasOpen = ChatInputBar.mediaGalleryOpen(prevProps);
     if (!imageGalleryIsOpen && imageGalleryWasOpen) {
       this.hideButtons();
     } else if (imageGalleryIsOpen && !imageGalleryWasOpen) {
       this.expandButtons();
       this.setIOSKeyboardHeight();
     }
   }
 
   addReplyListener() {
     invariant(
       this.props.inputState,
       'inputState should be set in addReplyListener',
     );
     this.props.inputState.addReplyListener(this.focusAndUpdateText);
   }
 
   removeReplyListener() {
     invariant(
       this.props.inputState,
       'inputState should be set in removeReplyListener',
     );
     this.props.inputState.removeReplyListener(this.focusAndUpdateText);
   }
 
   setIOSKeyboardHeight() {
     if (Platform.OS !== 'ios') {
       return;
     }
     const { textInput } = this;
     if (!textInput) {
       return;
     }
     const keyboardHeight = getKeyboardHeight();
     if (keyboardHeight === null || keyboardHeight === undefined) {
       return;
     }
     TextInputKeyboardMangerIOS.setKeyboardHeight(textInput, keyboardHeight);
   }
 
   get shouldShowTextInput(): boolean {
     if (threadHasPermission(this.props.threadInfo, threadPermissions.VOICED)) {
       return true;
     }
     // If the thread is created by somebody else while the viewer is attempting
     // to create it, the threadInfo might be modified in-place
     // and won't list the viewer as a member,
     // which will end up hiding the input.
     // In this case, we will assume that our creation action
     // will get translated into a join, and as long
     // as members are voiced, we can show the input.
     if (!this.props.threadCreationInProgress) {
       return false;
     }
     return checkIfDefaultMembersAreVoiced(this.props.threadInfo);
   }
 
   render() {
     const isMember = viewerIsMember(this.props.threadInfo);
     const canJoin = threadHasPermission(
       this.props.threadInfo,
       threadPermissions.JOIN_THREAD,
     );
     let joinButton = null;
     if (!isMember && canJoin && !this.props.threadCreationInProgress) {
       let buttonContent;
       if (this.props.joinThreadLoadingStatus === 'loading') {
         buttonContent = (
           <ActivityIndicator
             size="small"
             color="white"
             style={this.props.styles.joinThreadLoadingIndicator}
           />
         );
       } else {
         buttonContent = (
           <View style={this.props.styles.joinButtonContent}>
             <SWMansionIcon
               name="plus"
               style={this.props.styles.joinButtonText}
             />
-            <Text style={this.props.styles.joinButtonText}>Join Thread</Text>
+            <Text style={this.props.styles.joinButtonText}>Join Chat</Text>
           </View>
         );
       }
       joinButton = (
         <View style={this.props.styles.joinButtonContainer}>
           <Button
             onPress={this.onPressJoin}
             iosActiveOpacity={0.85}
             style={[
               this.props.styles.joinButton,
               { backgroundColor: `#${this.props.threadInfo.color}` },
             ]}
           >
             {buttonContent}
           </Button>
         </View>
       );
     }
 
     let content;
     const defaultMembersAreVoiced = checkIfDefaultMembersAreVoiced(
       this.props.threadInfo,
     );
     if (this.shouldShowTextInput) {
       content = this.renderInput();
     } else if (
       threadFrozenDueToViewerBlock(
         this.props.threadInfo,
         this.props.viewerID,
         this.props.userInfos,
       ) &&
       threadActualMembers(this.props.threadInfo.members).length === 2
     ) {
       content = (
         <Text style={this.props.styles.explanation}>
           You can&apos;t send messages to a user that you&apos;ve blocked.
         </Text>
       );
     } else if (isMember) {
       content = (
         <Text style={this.props.styles.explanation}>
           You don&apos;t have permission to send messages.
         </Text>
       );
     } else if (defaultMembersAreVoiced && canJoin) {
       content = null;
     } else {
       content = (
         <Text style={this.props.styles.explanation}>
           You don&apos;t have permission to send messages.
         </Text>
       );
     }
 
     const keyboardInputHost =
       Platform.OS === 'android' ? null : (
         <KeyboardInputHost textInputRef={this.textInput} />
       );
 
     return (
       <View
         style={this.props.styles.container}
         onLayout={this.props.onInputBarLayout}
       >
         {joinButton}
         {content}
         {keyboardInputHost}
       </View>
     );
   }
 
   renderInput() {
     const expandoButton = (
       <TouchableOpacity
         onPress={this.expandButtons}
         activeOpacity={0.4}
         style={this.props.styles.expandButton}
       >
         <AnimatedView style={this.expandIconStyle}>
           <SWMansionIcon
             name="chevron-right"
             size={22}
             color={`#${this.props.threadInfo.color}`}
           />
         </AnimatedView>
       </TouchableOpacity>
     );
     const threadColor = `#${this.props.threadInfo.color}`;
     return (
       <TouchableWithoutFeedback onPress={this.dismissKeyboard}>
         <View style={this.props.styles.inputContainer}>
           <AnimatedView style={this.expandoButtonsStyle}>
             <View style={this.props.styles.innerExpandoButtons}>
               {this.state.buttonsExpanded ? expandoButton : null}
               <TouchableOpacity
                 onPress={this.showMediaGallery}
                 activeOpacity={0.4}
               >
                 <AnimatedView style={this.cameraRollIconStyle}>
                   <SWMansionIcon
                     name="image-1"
                     size={24}
                     color={`#${this.props.threadInfo.color}`}
                   />
                 </AnimatedView>
               </TouchableOpacity>
               <TouchableOpacity
                 onPress={this.props.openCamera}
                 activeOpacity={0.4}
                 disabled={!this.state.buttonsExpanded}
               >
                 <AnimatedView style={this.cameraIconStyle}>
                   <SWMansionIcon
                     name="camera"
                     size={24}
                     color={`#${this.props.threadInfo.color}`}
                   />
                 </AnimatedView>
               </TouchableOpacity>
               {this.state.buttonsExpanded ? null : expandoButton}
             </View>
           </AnimatedView>
           <ClearableTextInput
             allowImagePasteForThreadID={this.props.threadInfo.id}
             value={this.state.text}
             onChangeText={this.updateText}
             placeholder="Send a message..."
             placeholderTextColor={this.props.colors.listInputButton}
             multiline={true}
             style={this.props.styles.textInput}
             textInputRef={this.textInputRef}
             ref={this.clearableTextInputRef}
             selectionColor={`#${this.props.threadInfo.color}`}
           />
           <AnimatedView style={this.sendButtonContainerStyle}>
             <TouchableOpacity
               onPress={this.onSend}
               activeOpacity={0.4}
               style={this.props.styles.sendButton}
               disabled={trimMessage(this.state.text) === ''}
             >
               <Icon
                 name="md-send"
                 size={25}
                 style={this.props.styles.sendIcon}
                 color={threadColor}
               />
             </TouchableOpacity>
           </AnimatedView>
         </View>
       </TouchableWithoutFeedback>
     );
   }
 
   textInputRef = (textInput: ?React.ElementRef<typeof TextInput>) => {
     this.textInput = textInput;
   };
 
   clearableTextInputRef = (clearableTextInput: ?ClearableTextInput) => {
     this.clearableTextInput = clearableTextInput;
   };
 
   updateText = (text: string) => {
     this.setState({ text, textEdited: true });
     this.saveDraft(text);
   };
 
   saveDraft = _throttle(text => {
     this.props.updateDraft({
       key: draftKeyFromThreadID(this.props.threadInfo.id),
       text,
     });
   }, 400);
 
   focusAndUpdateText = (text: string) => {
     const { textInput } = this;
     if (!textInput) {
       return;
     }
 
     const currentText = this.state.text;
     if (!currentText.startsWith(text)) {
       const prependedText = text.concat(currentText);
       this.updateText(prependedText);
       this.immediatelyShowSendButton();
       this.immediatelyHideButtons();
     }
 
     textInput.focus();
   };
 
   onSend = async () => {
     if (!trimMessage(this.state.text)) {
       return;
     }
     this.updateSendButton('');
 
     const { clearableTextInput } = this;
     invariant(
       clearableTextInput,
       'clearableTextInput should be sent in onSend',
     );
     let text = await clearableTextInput.getValueAndReset();
     text = trimMessage(text);
     if (!text) {
       return;
     }
 
     const localID = `${localIDPrefix}${this.props.nextLocalID}`;
     const creatorID = this.props.viewerID;
     invariant(creatorID, 'should have viewer ID in order to send a message');
     invariant(
       this.props.inputState,
       'inputState should be set in ChatInputBar.onSend',
     );
 
     this.props.inputState.sendTextMessage(
       {
         type: messageTypes.TEXT,
         localID,
         threadID: this.props.threadInfo.id,
         text,
         creatorID,
         time: Date.now(),
       },
       this.props.threadInfo,
     );
   };
 
   onPressJoin = () => {
     this.props.dispatchActionPromise(joinThreadActionTypes, this.joinAction());
   };
 
   async joinAction() {
     const query = this.props.calendarQuery();
     return await this.props.joinThread({
       threadID: this.props.threadInfo.id,
       calendarQuery: {
         startDate: query.startDate,
         endDate: query.endDate,
         filters: [
           ...query.filters,
           { type: 'threads', threadIDs: [this.props.threadInfo.id] },
         ],
       },
     });
   }
 
   expandButtons = () => {
     if (this.state.buttonsExpanded) {
       return;
     }
     this.targetExpandoButtonsOpen.setValue(1);
     this.setState({ buttonsExpanded: true });
   };
 
   hideButtons() {
     if (
       ChatInputBar.mediaGalleryOpen(this.props) ||
       !this.systemKeyboardShowing ||
       !this.state.buttonsExpanded
     ) {
       return;
     }
     this.targetExpandoButtonsOpen.setValue(0);
     this.setState({ buttonsExpanded: false });
   }
 
   immediatelyHideButtons() {
     this.expandoButtonsOpen.setValue(0);
     this.targetExpandoButtonsOpen.setValue(0);
     this.setState({ buttonsExpanded: false });
   }
 
   showMediaGallery = () => {
     const { keyboardState } = this.props;
     invariant(keyboardState, 'keyboardState should be initialized');
     keyboardState.showMediaGallery(this.props.threadInfo);
   };
 
   dismissKeyboard = () => {
     const { keyboardState } = this.props;
     keyboardState && keyboardState.dismissKeyboard();
   };
 }
 
 const unboundStyles = {
   cameraIcon: {
     paddingBottom: Platform.OS === 'android' ? 12 : 11,
     paddingRight: 4,
   },
   cameraRollIcon: {
     paddingBottom: Platform.OS === 'android' ? 12 : 11,
     paddingRight: 6,
   },
   container: {
     backgroundColor: 'listBackground',
   },
   expandButton: {
     bottom: 0,
     position: 'absolute',
     right: 0,
   },
   expandIcon: {
     paddingBottom: Platform.OS === 'android' ? 13 : 11,
   },
   expandoButtons: {
     alignSelf: 'flex-end',
   },
   explanation: {
     color: 'listBackgroundSecondaryLabel',
     paddingBottom: 4,
     paddingTop: 1,
     textAlign: 'center',
   },
   innerExpandoButtons: {
     alignItems: 'flex-end',
     alignSelf: 'flex-end',
     flexDirection: 'row',
   },
   inputContainer: {
     flexDirection: 'row',
   },
   joinButton: {
     borderRadius: 8,
     flex: 1,
     justifyContent: 'center',
     marginHorizontal: 12,
     marginVertical: 3,
   },
   joinButtonContainer: {
     flexDirection: 'row',
     height: 48,
     marginBottom: 8,
   },
   joinButtonContent: {
     flexDirection: 'row',
     justifyContent: 'center',
     alignItems: 'center',
   },
   joinButtonText: {
     color: 'listForegroundLabel',
     fontSize: 20,
     marginHorizontal: 4,
   },
   joinThreadLoadingIndicator: {
     paddingVertical: 2,
   },
   sendButton: {
     position: 'absolute',
     bottom: 4,
     left: 0,
   },
   sendIcon: {
     paddingLeft: 9,
     paddingRight: 8,
     paddingVertical: 6,
   },
   textInput: {
     backgroundColor: 'listInputBackground',
     borderRadius: 12,
     color: 'listForegroundLabel',
     fontSize: 16,
     marginLeft: 4,
     marginRight: 4,
     marginTop: 6,
     marginBottom: 8,
     maxHeight: 250,
     paddingHorizontal: 10,
     paddingVertical: 5,
   },
 };
 
 const joinThreadLoadingStatusSelector = createLoadingStatusSelector(
   joinThreadActionTypes,
 );
 const createThreadLoadingStatusSelector = createLoadingStatusSelector(
   newThreadActionTypes,
 );
 
 type ConnectedChatInputBarBaseProps = {
   ...BaseProps,
   +onInputBarLayout?: (event: LayoutEvent) => mixed,
   +openCamera: () => mixed,
 };
 function ConnectedChatInputBarBase(props: ConnectedChatInputBarBaseProps) {
   const navContext = React.useContext(NavContext);
   const keyboardState = React.useContext(KeyboardContext);
   const inputState = React.useContext(InputStateContext);
 
   const viewerID = useSelector(
     state => state.currentUserInfo && state.currentUserInfo.id,
   );
   const { draft, updateDraft, moveDraft } = useDrafts(props.threadInfo.id);
   const joinThreadLoadingStatus = useSelector(joinThreadLoadingStatusSelector);
   const createThreadLoadingStatus = useSelector(
     createThreadLoadingStatusSelector,
   );
   const threadCreationInProgress = createThreadLoadingStatus === 'loading';
   const calendarQuery = useSelector(state =>
     nonThreadCalendarQuery({
       redux: state,
       navContext,
     }),
   );
   const nextLocalID = useSelector(state => state.nextLocalID);
   const userInfos = useSelector(state => state.userStore.userInfos);
 
   const styles = useStyles(unboundStyles);
   const colors = useColors();
 
   const isActive = React.useMemo(
     () => props.threadInfo.id === activeThreadSelector(navContext),
     [props.threadInfo.id, navContext],
   );
 
   const dispatch = useDispatch();
   const dispatchActionPromise = useDispatchActionPromise();
   const callJoinThread = useServerCall(joinThread);
 
   return (
     <ChatInputBar
       {...props}
       viewerID={viewerID}
       draft={draft}
       updateDraft={updateDraft}
       moveDraft={moveDraft}
       joinThreadLoadingStatus={joinThreadLoadingStatus}
       threadCreationInProgress={threadCreationInProgress}
       calendarQuery={calendarQuery}
       nextLocalID={nextLocalID}
       userInfos={userInfos}
       colors={colors}
       styles={styles}
       isActive={isActive}
       keyboardState={keyboardState}
       dispatch={dispatch}
       dispatchActionPromise={dispatchActionPromise}
       joinThread={callJoinThread}
       inputState={inputState}
     />
   );
 }
 
 type DummyChatInputBarProps = {
   ...BaseProps,
   +onHeightMeasured: (height: number) => mixed,
 };
 const noop = () => {};
 function DummyChatInputBar(props: DummyChatInputBarProps): React.Node {
   const { onHeightMeasured, ...restProps } = props;
   const onInputBarLayout = React.useCallback(
     (event: LayoutEvent) => {
       const { height } = event.nativeEvent.layout;
       onHeightMeasured(height);
     },
     [onHeightMeasured],
   );
   return (
     <View pointerEvents="none">
       <ConnectedChatInputBarBase
         {...restProps}
         onInputBarLayout={onInputBarLayout}
         openCamera={noop}
       />
     </View>
   );
 }
 
 type ChatInputBarProps = {
   ...BaseProps,
   +navigation: ChatNavigationProp<'MessageList'>,
   +route: NavigationRoute<'MessageList'>,
 };
 const ConnectedChatInputBar: React.ComponentType<ChatInputBarProps> = React.memo<ChatInputBarProps>(
   function ConnectedChatInputBar(props: ChatInputBarProps) {
     const { navigation, route, ...restProps } = props;
     const keyboardState = React.useContext(KeyboardContext);
 
     const { threadInfo } = props;
     const imagePastedCallback = React.useCallback(
       imagePastedEvent => {
         if (threadInfo.id !== imagePastedEvent.threadID) {
           return;
         }
         const pastedImage: PhotoPaste = {
           step: 'photo_paste',
           dimensions: {
             height: imagePastedEvent.height,
             width: imagePastedEvent.width,
           },
           filename: imagePastedEvent.fileName,
           uri: 'file://' + imagePastedEvent.filePath,
           selectTime: 0,
           sendTime: 0,
           retries: 0,
         };
         navigation.navigate({
           name: ImagePasteModalRouteName,
           params: {
             imagePasteStagingInfo: pastedImage,
             thread: threadInfo,
           },
         });
       },
       [navigation, threadInfo],
     );
 
     React.useEffect(() => {
       const imagePasteListener = NativeAppEventEmitter.addListener(
         'imagePasted',
         imagePastedCallback,
       );
       return () => imagePasteListener.remove();
     }, [imagePastedCallback]);
 
     const chatContext = React.useContext(ChatContext);
     invariant(chatContext, 'should be set');
     const { setChatInputBarHeight, deleteChatInputBarHeight } = chatContext;
     const onInputBarLayout = React.useCallback(
       (event: LayoutEvent) => {
         const { height } = event.nativeEvent.layout;
         setChatInputBarHeight(threadInfo.id, height);
       },
       [threadInfo.id, setChatInputBarHeight],
     );
 
     React.useEffect(() => {
       return () => {
         deleteChatInputBarHeight(threadInfo.id);
       };
     }, [deleteChatInputBarHeight, threadInfo.id]);
 
     const openCamera = React.useCallback(() => {
       keyboardState?.dismissKeyboard();
       navigation.navigate({
         name: CameraModalRouteName,
         params: {
           presentedFrom: route.key,
           thread: threadInfo,
         },
       });
     }, [keyboardState, navigation, route.key, threadInfo]);
 
     return (
       <ConnectedChatInputBarBase
         {...restProps}
         onInputBarLayout={onInputBarLayout}
         openCamera={openCamera}
       />
     );
   },
 );
 
 export { ConnectedChatInputBar as ChatInputBar, DummyChatInputBar };
diff --git a/native/chat/chat-thread-list.react.js b/native/chat/chat-thread-list.react.js
index 7697894b7..3ec0916a7 100644
--- a/native/chat/chat-thread-list.react.js
+++ b/native/chat/chat-thread-list.react.js
@@ -1,647 +1,647 @@
 // @flow
 
 import invariant from 'invariant';
 import _sum from 'lodash/fp/sum';
 import * as React from 'react';
 import {
   View,
   FlatList,
   Platform,
   TextInput,
   TouchableWithoutFeedback,
   BackHandler,
 } from 'react-native';
 import { FloatingAction } from 'react-native-floating-action';
 import Animated from 'react-native-reanimated';
 import IonIcon from 'react-native-vector-icons/Ionicons';
 import { createSelector } from 'reselect';
 
 import { searchUsers } from 'lib/actions/user-actions';
 import {
   type ChatThreadItem,
   useFlattenedChatListData,
 } from 'lib/selectors/chat-selectors';
 import { threadSearchIndex as threadSearchIndexSelector } from 'lib/selectors/nav-selectors';
 import { usersWithPersonalThreadSelector } from 'lib/selectors/user-selectors';
 import SearchIndex from 'lib/shared/search-index';
 import {
   createPendingThread,
   getThreadListSearchResults,
 } from 'lib/shared/thread-utils';
 import type { UserSearchResult } from 'lib/types/search-types';
 import type { ThreadInfo } from 'lib/types/thread-types';
 import { threadTypes } from 'lib/types/thread-types';
 import type { GlobalAccountUserInfo, UserInfo } from 'lib/types/user-types';
 import { useServerCall } from 'lib/utils/action-utils';
 
 import Button from '../components/button.react';
 import Search from '../components/search.react';
 import type { TabNavigationProp } from '../navigation/app-navigator.react';
 import {
   SidebarListModalRouteName,
   HomeChatThreadListRouteName,
   BackgroundChatThreadListRouteName,
   type NavigationRoute,
 } from '../navigation/route-names';
 import { useSelector } from '../redux/redux-utils';
 import {
   type IndicatorStyle,
   indicatorStyleSelector,
   useStyles,
 } from '../themes/colors';
 import type { ScrollEvent } from '../types/react-native';
 import { AnimatedView, type AnimatedStyleObj } from '../types/styles';
 import { animateTowards } from '../utils/animation-utils';
 import {
   ChatThreadListItem,
   chatThreadListItemHeight,
   spacerHeight,
 } from './chat-thread-list-item.react';
 import type {
   ChatTopTabsNavigationProp,
   ChatNavigationProp,
 } from './chat.react';
 import {
   type MessageListParams,
   useNavigateToThread,
 } from './message-list-types';
 import { sidebarHeight } from './sidebar-item.react';
 
 const floatingActions = [
   {
     text: 'Compose',
     icon: <IonIcon name="md-create" size={24} color="#FFFFFF" />,
     name: 'compose',
     position: 1,
   },
 ];
 
 /* eslint-disable import/no-named-as-default-member */
 const { Value, Node, interpolateNode } = Animated;
 /* eslint-enable import/no-named-as-default-member */
 
 type Item =
   | ChatThreadItem
   | { +type: 'search', +searchText: string }
   | { +type: 'empty', +emptyItem: React.ComponentType<{}> };
 
 type BaseProps = {
   +navigation:
     | ChatTopTabsNavigationProp<'HomeChatThreadList'>
     | ChatTopTabsNavigationProp<'BackgroundChatThreadList'>,
   +route:
     | NavigationRoute<'HomeChatThreadList'>
     | NavigationRoute<'BackgroundChatThreadList'>,
   +filterThreads: (threadItem: ThreadInfo) => boolean,
   +emptyItem?: React.ComponentType<{}>,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +chatListData: $ReadOnlyArray<ChatThreadItem>,
   +viewerID: ?string,
   +threadSearchIndex: SearchIndex,
   +styles: typeof unboundStyles,
   +indicatorStyle: IndicatorStyle,
   +usersWithPersonalThread: $ReadOnlySet<string>,
   +navigateToThread: (params: MessageListParams) => void,
   // async functions that hit server APIs
   +searchUsers: (usernamePrefix: string) => Promise<UserSearchResult>,
 };
 type SearchStatus = 'inactive' | 'activating' | 'active';
 type State = {
   +searchStatus: SearchStatus,
   +searchText: string,
   +threadsSearchResults: Set<string>,
   +usersSearchResults: $ReadOnlyArray<GlobalAccountUserInfo>,
   +openedSwipeableId: string,
   +numItemsToDisplay: number,
 };
 type PropsAndState = { ...Props, ...State };
 class ChatThreadList extends React.PureComponent<Props, State> {
   state: State = {
     searchStatus: 'inactive',
     searchText: '',
     threadsSearchResults: new Set(),
     usersSearchResults: [],
     openedSwipeableId: '',
     numItemsToDisplay: 25,
   };
   searchInput: ?React.ElementRef<typeof TextInput>;
   flatList: ?FlatList<Item>;
   scrollPos = 0;
   clearNavigationBlurListener: ?() => mixed;
   searchCancelButtonOpen: Value = new Value(0);
   searchCancelButtonProgress: Node;
   searchCancelButtonOffset: Node;
 
   constructor(props: Props) {
     super(props);
     this.searchCancelButtonProgress = animateTowards(
       this.searchCancelButtonOpen,
       100,
     );
     this.searchCancelButtonOffset = interpolateNode(
       this.searchCancelButtonProgress,
       { inputRange: [0, 1], outputRange: [0, 56] },
     );
   }
 
   componentDidMount() {
     this.clearNavigationBlurListener = this.props.navigation.addListener(
       'blur',
       () => {
         this.setState({ numItemsToDisplay: 25 });
       },
     );
 
     const chatNavigation: ?ChatNavigationProp<
       'ChatThreadList',
     > = this.props.navigation.dangerouslyGetParent();
     invariant(chatNavigation, 'ChatNavigator should be within TabNavigator');
     const tabNavigation: ?TabNavigationProp<
       'Chat',
     > = chatNavigation.dangerouslyGetParent();
     invariant(tabNavigation, 'ChatNavigator should be within TabNavigator');
     tabNavigation.addListener('tabPress', this.onTabPress);
 
     BackHandler.addEventListener('hardwareBackPress', this.hardwareBack);
   }
 
   componentWillUnmount() {
     this.clearNavigationBlurListener && this.clearNavigationBlurListener();
 
     const chatNavigation: ?ChatNavigationProp<
       'ChatThreadList',
     > = this.props.navigation.dangerouslyGetParent();
     invariant(chatNavigation, 'ChatNavigator should be within TabNavigator');
     const tabNavigation: ?TabNavigationProp<
       'Chat',
     > = chatNavigation.dangerouslyGetParent();
     invariant(tabNavigation, 'ChatNavigator should be within TabNavigator');
     tabNavigation.removeListener('tabPress', this.onTabPress);
 
     BackHandler.removeEventListener('hardwareBackPress', this.hardwareBack);
   }
 
   hardwareBack = () => {
     if (!this.props.navigation.isFocused()) {
       return false;
     }
 
     const { searchStatus } = this.state;
     const isActiveOrActivating =
       searchStatus === 'active' || searchStatus === 'activating';
     if (!isActiveOrActivating) {
       return false;
     }
 
     this.onSearchCancel();
     return true;
   };
 
   componentDidUpdate(prevProps: Props, prevState: State) {
     const { searchStatus } = this.state;
     const prevSearchStatus = prevState.searchStatus;
 
     const isActiveOrActivating =
       searchStatus === 'active' || searchStatus === 'activating';
     const wasActiveOrActivating =
       prevSearchStatus === 'active' || prevSearchStatus === 'activating';
     if (isActiveOrActivating && !wasActiveOrActivating) {
       this.searchCancelButtonOpen.setValue(1);
     } else if (!isActiveOrActivating && wasActiveOrActivating) {
       this.searchCancelButtonOpen.setValue(0);
     }
 
     const { flatList } = this;
     if (!flatList) {
       return;
     }
 
     if (this.state.searchText !== prevState.searchText) {
       flatList.scrollToOffset({ offset: 0, animated: false });
       return;
     }
 
     if (searchStatus === 'activating' && prevSearchStatus === 'inactive') {
       flatList.scrollToOffset({ offset: 0, animated: true });
     }
   }
 
   onTabPress = () => {
     if (!this.props.navigation.isFocused()) {
       return;
     }
     if (this.scrollPos > 0 && this.flatList) {
       this.flatList.scrollToOffset({ offset: 0, animated: true });
     } else if (this.props.route.name === BackgroundChatThreadListRouteName) {
       this.props.navigation.navigate({ name: HomeChatThreadListRouteName });
     }
   };
 
   onSearchFocus = () => {
     if (this.state.searchStatus !== 'inactive') {
       return;
     }
     if (this.scrollPos === 0) {
       this.setState({ searchStatus: 'active' });
     } else {
       this.setState({ searchStatus: 'activating' });
     }
   };
 
   clearSearch() {
     const { flatList } = this;
     flatList && flatList.scrollToOffset({ offset: 0, animated: false });
     this.setState({ searchStatus: 'inactive' });
   }
 
   onSearchBlur = () => {
     if (this.state.searchStatus !== 'active') {
       return;
     }
     this.clearSearch();
   };
 
   onSearchCancel = () => {
     this.onChangeSearchText('');
     this.clearSearch();
   };
 
   renderSearch(additionalProps?: $Shape<React.ElementConfig<typeof Search>>) {
     const animatedSearchBoxStyle: AnimatedStyleObj = {
       marginRight: this.searchCancelButtonOffset,
     };
     const searchBoxStyle = [
       this.props.styles.searchBox,
       animatedSearchBoxStyle,
     ];
     const buttonStyle = [
       this.props.styles.cancelSearchButtonText,
       { opacity: this.searchCancelButtonProgress },
     ];
     return (
       <View style={this.props.styles.searchContainer}>
         <Button
           onPress={this.onSearchCancel}
           disabled={this.state.searchStatus !== 'active'}
           style={this.props.styles.cancelSearchButton}
         >
           {/* eslint-disable react-native/no-raw-text */}
           <Animated.Text style={buttonStyle}>Cancel</Animated.Text>
           {/* eslint-enable react-native/no-raw-text */}
         </Button>
         <AnimatedView style={searchBoxStyle}>
           <Search
             searchText={this.state.searchText}
             onChangeText={this.onChangeSearchText}
             containerStyle={this.props.styles.search}
             onBlur={this.onSearchBlur}
-            placeholder="Search threads"
+            placeholder="Search chats"
             ref={this.searchInputRef}
             {...additionalProps}
           />
         </AnimatedView>
       </View>
     );
   }
 
   searchInputRef = (searchInput: ?React.ElementRef<typeof TextInput>) => {
     this.searchInput = searchInput;
   };
 
   renderItem = (row: { item: Item, ... }) => {
     const item = row.item;
     if (item.type === 'search') {
       return (
         <TouchableWithoutFeedback onPress={this.onSearchFocus}>
           {this.renderSearch({ active: false })}
         </TouchableWithoutFeedback>
       );
     }
     if (item.type === 'empty') {
       const EmptyItem = item.emptyItem;
       return <EmptyItem />;
     }
     return (
       <ChatThreadListItem
         data={item}
         onPressItem={this.onPressItem}
         onPressSeeMoreSidebars={this.onPressSeeMoreSidebars}
         onSwipeableWillOpen={this.onSwipeableWillOpen}
         currentlyOpenedSwipeableId={this.state.openedSwipeableId}
       />
     );
   };
 
   static keyExtractor = (item: Item) => {
     if (item.type === 'chatThreadItem') {
       return item.threadInfo.id;
     } else if (item.type === 'empty') {
       return 'empty';
     } else {
       return 'search';
     }
   };
 
   static getItemLayout = (data: ?$ReadOnlyArray<Item>, index: number) => {
     if (!data) {
       return { length: 0, offset: 0, index };
     }
     const offset = ChatThreadList.heightOfItems(
       data.filter((_, i) => i < index),
     );
     const item = data[index];
     const length = item ? ChatThreadList.itemHeight(item) : 0;
     return { length, offset, index };
   };
 
   static itemHeight = (item: Item) => {
     if (item.type === 'search') {
       return Platform.OS === 'ios' ? 54.5 : 55;
     }
 
     // itemHeight for emptyItem might be wrong because of line wrapping
     // but we don't care because we'll only ever be rendering this item
     // by itself and it should always be on-screen
     if (item.type === 'empty') {
       return 123;
     }
 
     let height = chatThreadListItemHeight;
     height += item.sidebars.length * sidebarHeight;
     if (item.sidebars.length > 0) {
       height += spacerHeight;
     }
     return height;
   };
 
   static heightOfItems(data: $ReadOnlyArray<Item>): number {
     return _sum(data.map(ChatThreadList.itemHeight));
   }
 
   listDataSelector = createSelector(
     (propsAndState: PropsAndState) => propsAndState.chatListData,
     (propsAndState: PropsAndState) => propsAndState.searchStatus,
     (propsAndState: PropsAndState) => propsAndState.searchText,
     (propsAndState: PropsAndState) => propsAndState.threadsSearchResults,
     (propsAndState: PropsAndState) => propsAndState.emptyItem,
     (propsAndState: PropsAndState) => propsAndState.usersSearchResults,
     (propsAndState: PropsAndState) => propsAndState.filterThreads,
     (propsAndState: PropsAndState) => propsAndState.viewerID,
     (
       reduxChatListData: $ReadOnlyArray<ChatThreadItem>,
       searchStatus: SearchStatus,
       searchText: string,
       threadsSearchResults: Set<string>,
       emptyItem?: React.ComponentType<{}>,
       usersSearchResults: $ReadOnlyArray<GlobalAccountUserInfo>,
       filterThreads: ThreadInfo => boolean,
       viewerID: ?string,
     ): $ReadOnlyArray<Item> => {
       const chatThreadItems = getThreadListSearchResults(
         reduxChatListData,
         searchText,
         filterThreads,
         threadsSearchResults,
         usersSearchResults,
         viewerID,
       );
 
       const chatItems: Item[] = [...chatThreadItems];
 
       if (emptyItem && chatItems.length === 0) {
         chatItems.push({ type: 'empty', emptyItem });
       }
 
       if (searchStatus === 'inactive' || searchStatus === 'activating') {
         chatItems.unshift({ type: 'search', searchText });
       }
 
       return chatItems;
     },
   );
 
   partialListDataSelector = createSelector(
     this.listDataSelector,
     (propsAndState: PropsAndState) => propsAndState.numItemsToDisplay,
     (items: $ReadOnlyArray<Item>, numItemsToDisplay: number) =>
       items.slice(0, numItemsToDisplay),
   );
 
   get fullListData() {
     return this.listDataSelector({ ...this.props, ...this.state });
   }
 
   get listData() {
     return this.partialListDataSelector({ ...this.props, ...this.state });
   }
 
   onEndReached = () => {
     if (this.listData.length === this.fullListData.length) {
       return;
     }
     this.setState(prevState => ({
       numItemsToDisplay: prevState.numItemsToDisplay + 25,
     }));
   };
 
   render() {
     let floatingAction;
     if (Platform.OS === 'android') {
       floatingAction = (
         <FloatingAction
           actions={floatingActions}
           overrideWithAction
           onPressItem={this.composeThread}
           color="#7e57c2"
         />
       );
     }
     let fixedSearch;
     const { searchStatus } = this.state;
     if (searchStatus === 'active') {
       fixedSearch = this.renderSearch({ autoFocus: true });
     }
     const scrollEnabled =
       searchStatus === 'inactive' || searchStatus === 'active';
     // this.props.viewerID is in extraData since it's used by MessagePreview
     // within ChatThreadListItem
     return (
       <View style={this.props.styles.container}>
         {fixedSearch}
         <FlatList
           data={this.listData}
           renderItem={this.renderItem}
           keyExtractor={ChatThreadList.keyExtractor}
           getItemLayout={ChatThreadList.getItemLayout}
           extraData={`${this.props.viewerID || ''} ${
             this.state.openedSwipeableId
           }`}
           initialNumToRender={11}
           keyboardShouldPersistTaps="handled"
           onScroll={this.onScroll}
           style={this.props.styles.flatList}
           indicatorStyle={this.props.indicatorStyle}
           scrollEnabled={scrollEnabled}
           onEndReached={this.onEndReached}
           onEndReachedThreshold={1}
           ref={this.flatListRef}
         />
         {floatingAction}
       </View>
     );
   }
 
   flatListRef = (flatList: ?FlatList<Item>) => {
     this.flatList = flatList;
   };
 
   onScroll = (event: ScrollEvent) => {
     const oldScrollPos = this.scrollPos;
     this.scrollPos = event.nativeEvent.contentOffset.y;
     if (this.scrollPos !== 0 || oldScrollPos === 0) {
       return;
     }
     if (this.state.searchStatus === 'activating') {
       this.setState({ searchStatus: 'active' });
     }
   };
 
   async searchUsers(usernamePrefix: string) {
     if (usernamePrefix.length === 0) {
       return [];
     }
 
     const { userInfos } = await this.props.searchUsers(usernamePrefix);
     return userInfos.filter(
       info =>
         !this.props.usersWithPersonalThread.has(info.id) &&
         info.id !== this.props.viewerID,
     );
   }
 
   onChangeSearchText = async (searchText: string) => {
     const results = this.props.threadSearchIndex.getSearchResults(searchText);
     this.setState({
       searchText,
       threadsSearchResults: new Set(results),
       numItemsToDisplay: 25,
     });
     const usersSearchResults = await this.searchUsers(searchText);
     this.setState({ usersSearchResults });
   };
 
   onPressItem = (
     threadInfo: ThreadInfo,
     pendingPersonalThreadUserInfo?: UserInfo,
   ) => {
     this.onChangeSearchText('');
     if (this.searchInput) {
       this.searchInput.blur();
     }
     this.props.navigateToThread({ threadInfo, pendingPersonalThreadUserInfo });
   };
 
   onPressSeeMoreSidebars = (threadInfo: ThreadInfo) => {
     this.onChangeSearchText('');
     if (this.searchInput) {
       this.searchInput.blur();
     }
     this.props.navigation.navigate({
       name: SidebarListModalRouteName,
       params: { threadInfo },
     });
   };
 
   onSwipeableWillOpen = (threadInfo: ThreadInfo) => {
     this.setState(state => ({ ...state, openedSwipeableId: threadInfo.id }));
   };
 
   composeThread = () => {
     if (!this.props.viewerID) {
       return;
     }
     const threadInfo = createPendingThread({
       viewerID: this.props.viewerID,
       threadType: threadTypes.PRIVATE,
     });
     this.props.navigateToThread({ threadInfo, searching: true });
   };
 }
 
 const unboundStyles = {
   icon: {
     fontSize: 28,
   },
   container: {
     flex: 1,
   },
   searchContainer: {
     backgroundColor: 'listBackground',
     display: 'flex',
     justifyContent: 'center',
     flexDirection: 'row',
   },
   searchBox: {
     flex: 1,
   },
   search: {
     marginBottom: 8,
     marginHorizontal: 18,
     marginTop: 16,
   },
   cancelSearchButton: {
     position: 'absolute',
     right: 0,
     top: 0,
     bottom: 0,
     display: 'flex',
     justifyContent: 'center',
   },
   cancelSearchButtonText: {
     color: 'link',
     fontSize: 16,
     paddingHorizontal: 16,
     paddingTop: 8,
   },
   flatList: {
     flex: 1,
     backgroundColor: 'listBackground',
   },
 };
 
 const ConnectedChatThreadList: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedChatThreadList(props: BaseProps) {
     const boundChatListData = useFlattenedChatListData();
     const viewerID = useSelector(
       state => state.currentUserInfo && state.currentUserInfo.id,
     );
     const threadSearchIndex = useSelector(threadSearchIndexSelector);
     const styles = useStyles(unboundStyles);
     const indicatorStyle = useSelector(indicatorStyleSelector);
     const callSearchUsers = useServerCall(searchUsers);
     const usersWithPersonalThread = useSelector(
       usersWithPersonalThreadSelector,
     );
 
     const navigateToThread = useNavigateToThread();
 
     return (
       <ChatThreadList
         {...props}
         chatListData={boundChatListData}
         viewerID={viewerID}
         threadSearchIndex={threadSearchIndex}
         styles={styles}
         indicatorStyle={indicatorStyle}
         searchUsers={callSearchUsers}
         usersWithPersonalThread={usersWithPersonalThread}
         navigateToThread={navigateToThread}
       />
     );
   },
 );
 
 export default ConnectedChatThreadList;
diff --git a/native/chat/chat.react.js b/native/chat/chat.react.js
index 003907e5d..d54b4472b 100644
--- a/native/chat/chat.react.js
+++ b/native/chat/chat.react.js
@@ -1,306 +1,306 @@
 // @flow
 
 import {
   createMaterialTopTabNavigator,
   type MaterialTopTabNavigationProp,
 } from '@react-navigation/material-top-tabs';
 import {
   createNavigatorFactory,
   useNavigationBuilder,
   type StackNavigationState,
   type StackOptions,
   type StackNavigationEventMap,
   type StackNavigatorProps,
   type ExtraStackNavigatorProps,
   type StackHeaderProps as CoreStackHeaderProps,
 } from '@react-navigation/native';
 import { StackView, type StackHeaderProps } from '@react-navigation/stack';
 import invariant from 'invariant';
 import * as React from 'react';
 import { Platform, View } from 'react-native';
 import { useSelector } from 'react-redux';
 
 import { isLoggedIn } from 'lib/selectors/user-selectors';
 import { threadIsPending } from 'lib/shared/thread-utils';
 import { firstLine } from 'lib/utils/string-utils';
 
 import KeyboardAvoidingView from '../components/keyboard-avoiding-view.react';
 import SWMansionIcon from '../components/swmansion-icon.react';
 import { InputStateContext } from '../input/input-state';
 import HeaderBackButton from '../navigation/header-back-button.react';
 import { defaultStackScreenOptions } from '../navigation/options';
 import {
   ComposeSubchannelRouteName,
   DeleteThreadRouteName,
   ThreadSettingsRouteName,
   MessageListRouteName,
   ChatThreadListRouteName,
   HomeChatThreadListRouteName,
   BackgroundChatThreadListRouteName,
   type ScreenParamList,
   type ChatParamList,
   type ChatTopTabsParamList,
 } from '../navigation/route-names';
 import { useColors, useStyles } from '../themes/colors';
 import BackgroundChatThreadList from './background-chat-thread-list.react';
 import ChatHeader from './chat-header.react';
 import ChatRouter, { type ChatRouterNavigationProp } from './chat-router';
 import ComposeSubchannel from './compose-subchannel.react';
 import ComposeThreadButton from './compose-thread-button.react';
 import HomeChatThreadList from './home-chat-thread-list.react';
 import MessageListContainer from './message-list-container.react';
 import MessageListHeaderTitle from './message-list-header-title.react';
 import MessageStorePruner from './message-store-pruner.react';
 import DeleteThread from './settings/delete-thread.react';
 import ThreadSettings from './settings/thread-settings.react';
 import ThreadDraftUpdater from './thread-draft-updater.react';
 import ThreadScreenPruner from './thread-screen-pruner.react';
 import ThreadSettingsButton from './thread-settings-button.react';
 
 const unboundStyles = {
   keyboardAvoidingView: {
     flex: 1,
   },
   view: {
     flex: 1,
     backgroundColor: 'listBackground',
   },
   threadListHeaderStyle: {
     elevation: 0,
     shadowOffset: { width: 0, height: 0 },
     borderBottomWidth: 0,
     backgroundColor: '#0A0A0A',
   },
 };
 
 export type ChatTopTabsNavigationProp<
   RouteName: $Keys<ChatTopTabsParamList> = $Keys<ChatTopTabsParamList>,
 > = MaterialTopTabNavigationProp<ScreenParamList, RouteName>;
 
 const homeChatThreadListOptions = {
   title: 'Focused',
   // eslint-disable-next-line react/display-name
   tabBarIcon: ({ color }) => (
     <SWMansionIcon name="home-1" size={22} style={{ color }} />
   ),
 };
 const backgroundChatThreadListOptions = {
   title: 'Background',
   // eslint-disable-next-line react/display-name
   tabBarIcon: ({ color }) => (
     <SWMansionIcon name="bell-disabled" size={22} style={{ color }} />
   ),
 };
 
 const ChatThreadsTopTab = createMaterialTopTabNavigator();
 function ChatThreadsComponent(): React.Node {
   const colors = useColors();
   const { tabBarBackground, tabBarAccent } = colors;
   const tabBarOptions = React.useMemo(
     () => ({
       showIcon: true,
       style: {
         backgroundColor: tabBarBackground,
       },
       tabStyle: {
         flexDirection: 'row',
       },
       indicatorStyle: {
         borderColor: tabBarAccent,
         borderBottomWidth: 2,
       },
     }),
     [tabBarAccent, tabBarBackground],
   );
   return (
     <ChatThreadsTopTab.Navigator tabBarOptions={tabBarOptions}>
       <ChatThreadsTopTab.Screen
         name={HomeChatThreadListRouteName}
         component={HomeChatThreadList}
         options={homeChatThreadListOptions}
       />
       <ChatThreadsTopTab.Screen
         name={BackgroundChatThreadListRouteName}
         component={BackgroundChatThreadList}
         options={backgroundChatThreadListOptions}
       />
     </ChatThreadsTopTab.Navigator>
   );
 }
 
 type ChatNavigatorProps = StackNavigatorProps<ChatRouterNavigationProp<>>;
 function ChatNavigator({
   initialRouteName,
   children,
   screenOptions,
   ...rest
 }: ChatNavigatorProps) {
   const { state, descriptors, navigation } = useNavigationBuilder(ChatRouter, {
     initialRouteName,
     children,
     screenOptions,
   });
 
   // Clear ComposeSubchannel screens after each message is sent. If a user goes
   // to ComposeSubchannel to create a new thread, but finds an existing one and
   // uses it instead, we can assume the intent behind opening ComposeSubchannel
   // is resolved
   const inputState = React.useContext(InputStateContext);
   invariant(inputState, 'InputState should be set in ChatNavigator');
   const clearComposeScreensAfterMessageSend = React.useCallback(() => {
     navigation.clearScreens([ComposeSubchannelRouteName]);
   }, [navigation]);
   React.useEffect(() => {
     inputState.registerSendCallback(clearComposeScreensAfterMessageSend);
     return () => {
       inputState.unregisterSendCallback(clearComposeScreensAfterMessageSend);
     };
   }, [inputState, clearComposeScreensAfterMessageSend]);
 
   return (
     <StackView
       {...rest}
       state={state}
       descriptors={descriptors}
       navigation={navigation}
       detachInactiveScreens={Platform.OS !== 'ios'}
     />
   );
 }
 const createChatNavigator = createNavigatorFactory<
   StackNavigationState,
   StackOptions,
   StackNavigationEventMap,
   ChatRouterNavigationProp<>,
   ExtraStackNavigatorProps,
 >(ChatNavigator);
 
 const header = (props: CoreStackHeaderProps) => {
   // Flow has trouble reconciling identical types between different libdefs,
   // and flow-typed has no way for one libdef to depend on another
   const castProps: StackHeaderProps = (props: any);
   return <ChatHeader {...castProps} />;
 };
 const headerBackButton = props => <HeaderBackButton {...props} />;
 
 const chatThreadListOptions = ({ navigation }) => ({
   headerTitle: 'Inbox',
   headerRight:
     Platform.OS === 'ios'
       ? () => <ComposeThreadButton navigate={navigation.navigate} />
       : undefined,
   headerBackTitleVisible: false,
   headerStyle: unboundStyles.threadListHeaderStyle,
 });
 const messageListOptions = ({ navigation, route }) => ({
   // This is a render prop, not a component
   // eslint-disable-next-line react/display-name
   headerTitle: () => (
     <MessageListHeaderTitle
       threadInfo={route.params.threadInfo}
       searching={route.params.searching}
       navigate={navigation.navigate}
     />
   ),
   headerTitleContainerStyle: {
     marginHorizontal: Platform.select({ ios: 80, default: 0 }),
     flex: 1,
   },
   headerRight:
     Platform.OS === 'android' && !threadIsPending(route.params.threadInfo.id)
       ? // This is a render prop, not a component
         // eslint-disable-next-line react/display-name
         () => (
           <ThreadSettingsButton
             threadInfo={route.params.threadInfo}
             navigate={navigation.navigate}
           />
         )
       : undefined,
   headerBackTitleVisible: false,
 });
 const composeThreadOptions = {
-  headerTitle: 'Compose thread',
+  headerTitle: 'Compose chat',
   headerBackTitleVisible: false,
 };
 const threadSettingsOptions = ({ route }) => ({
   headerTitle: firstLine(route.params.threadInfo.uiName),
   headerBackTitleVisible: false,
 });
 const deleteThreadOptions = {
-  headerTitle: 'Delete thread',
+  headerTitle: 'Delete chat',
   headerBackTitleVisible: false,
 };
 
 export type ChatNavigationProp<
   RouteName: $Keys<ChatParamList> = $Keys<ChatParamList>,
 > = ChatRouterNavigationProp<ScreenParamList, RouteName>;
 
 const Chat = createChatNavigator<
   ScreenParamList,
   ChatParamList,
   ChatNavigationProp<>,
 >();
 // eslint-disable-next-line no-unused-vars
 export default function ChatComponent(props: { ... }): React.Node {
   const styles = useStyles(unboundStyles);
   const colors = useColors();
   const loggedIn = useSelector(isLoggedIn);
   let draftUpdater = null;
   if (loggedIn) {
     draftUpdater = <ThreadDraftUpdater />;
   }
 
   const screenOptions = React.useMemo(
     () => ({
       ...defaultStackScreenOptions,
       header,
       headerLeft: headerBackButton,
       headerStyle: {
         backgroundColor: colors.tabBarBackground,
         borderBottomWidth: 1,
       },
     }),
     [colors.tabBarBackground],
   );
 
   return (
     <View style={styles.view}>
       <KeyboardAvoidingView
         behavior="padding"
         style={styles.keyboardAvoidingView}
       >
         <Chat.Navigator screenOptions={screenOptions}>
           <Chat.Screen
             name={ChatThreadListRouteName}
             component={ChatThreadsComponent}
             options={chatThreadListOptions}
           />
           <Chat.Screen
             name={MessageListRouteName}
             component={MessageListContainer}
             options={messageListOptions}
           />
           <Chat.Screen
             name={ComposeSubchannelRouteName}
             component={ComposeSubchannel}
             options={composeThreadOptions}
           />
           <Chat.Screen
             name={ThreadSettingsRouteName}
             component={ThreadSettings}
             options={threadSettingsOptions}
           />
           <Chat.Screen
             name={DeleteThreadRouteName}
             component={DeleteThread}
             options={deleteThreadOptions}
           />
         </Chat.Navigator>
         <MessageStorePruner />
         <ThreadScreenPruner />
         {draftUpdater}
       </KeyboardAvoidingView>
     </View>
   );
 }
diff --git a/native/chat/compose-subchannel.react.js b/native/chat/compose-subchannel.react.js
index e1bb5fbcb..e22772bd7 100644
--- a/native/chat/compose-subchannel.react.js
+++ b/native/chat/compose-subchannel.react.js
@@ -1,482 +1,482 @@
 // @flow
 
 import invariant from 'invariant';
 import _filter from 'lodash/fp/filter';
 import _flow from 'lodash/fp/flow';
 import _sortBy from 'lodash/fp/sortBy';
 import * as React from 'react';
 import { View, Text, Alert } from 'react-native';
 import { createSelector } from 'reselect';
 
 import { newThreadActionTypes, newThread } from 'lib/actions/thread-actions';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors';
 import {
   userInfoSelectorForPotentialMembers,
   userSearchIndexForPotentialMembers,
 } from 'lib/selectors/user-selectors';
 import SearchIndex from 'lib/shared/search-index';
 import { getPotentialMemberItems } from 'lib/shared/search-utils';
 import { threadInFilterList, userIsMember } from 'lib/shared/thread-utils';
 import type { CalendarQuery } from 'lib/types/entry-types';
 import type { LoadingStatus } from 'lib/types/loading-types';
 import {
   type ThreadInfo,
   type ThreadType,
   threadTypes,
   type ClientNewThreadRequest,
   type NewThreadResult,
 } from 'lib/types/thread-types';
 import { type AccountUserInfo } from 'lib/types/user-types';
 import type { DispatchActionPromise } from 'lib/utils/action-utils';
 import {
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils';
 
 import LinkButton from '../components/link-button.react';
 import { createTagInput, BaseTagInput } from '../components/tag-input.react';
 import ThreadList from '../components/thread-list.react';
 import UserList from '../components/user-list.react';
 import { useCalendarQuery } from '../navigation/nav-selectors';
 import type { NavigationRoute } from '../navigation/route-names';
 import { useSelector } from '../redux/redux-utils';
 import { useStyles } from '../themes/colors';
 import type { ChatNavigationProp } from './chat.react';
 import {
   type MessageListParams,
   useNavigateToThread,
 } from './message-list-types';
 import ParentThreadHeader from './parent-thread-header.react';
 
 const TagInput = createTagInput<AccountUserInfo>();
 
 const tagInputProps = {
   placeholder: 'username',
   autoFocus: true,
   returnKeyType: 'go',
 };
 
 export type ComposeSubchannelParams = {
   +threadType: ThreadType,
   +parentThreadInfo: ThreadInfo,
 };
 
 type BaseProps = {
   +navigation: ChatNavigationProp<'ComposeSubchannel'>,
   +route: NavigationRoute<'ComposeSubchannel'>,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +parentThreadInfo: ?ThreadInfo,
   +communityThreadInfo: ?ThreadInfo,
   +loadingStatus: LoadingStatus,
   +otherUserInfos: { +[id: string]: AccountUserInfo },
   +userSearchIndex: SearchIndex,
   +threadInfos: { +[id: string]: ThreadInfo },
   +styles: typeof unboundStyles,
   +calendarQuery: () => CalendarQuery,
   +navigateToThread: (params: MessageListParams) => void,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +newThread: (request: ClientNewThreadRequest) => Promise<NewThreadResult>,
 };
 type State = {
   +usernameInputText: string,
   +userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
 };
 type PropsAndState = { ...Props, ...State };
 class ComposeSubchannel extends React.PureComponent<Props, State> {
   state: State = {
     usernameInputText: '',
     userInfoInputArray: [],
   };
   tagInput: ?BaseTagInput<AccountUserInfo>;
   createThreadPressed = false;
   waitingOnThreadID: ?string;
 
   componentDidMount() {
     this.setLinkButton(true);
   }
 
   setLinkButton(enabled: boolean) {
     this.props.navigation.setOptions({
       headerRight: () => (
         <LinkButton
           text="Create"
           onPress={this.onPressCreateThread}
           disabled={!enabled}
         />
       ),
     });
   }
 
   componentDidUpdate(prevProps: Props) {
     const oldReduxParentThreadInfo = prevProps.parentThreadInfo;
     const newReduxParentThreadInfo = this.props.parentThreadInfo;
     if (
       newReduxParentThreadInfo &&
       newReduxParentThreadInfo !== oldReduxParentThreadInfo
     ) {
       this.props.navigation.setParams({
         parentThreadInfo: newReduxParentThreadInfo,
       });
     }
 
     if (
       this.waitingOnThreadID &&
       this.props.threadInfos[this.waitingOnThreadID] &&
       !prevProps.threadInfos[this.waitingOnThreadID]
     ) {
       const threadInfo = this.props.threadInfos[this.waitingOnThreadID];
       this.props.navigation.pushNewThread(threadInfo);
     }
   }
 
   static getParentThreadInfo(props: {
     route: NavigationRoute<'ComposeSubchannel'>,
     ...
   }): ThreadInfo {
     return props.route.params.parentThreadInfo;
   }
 
   userSearchResultsSelector = createSelector(
     (propsAndState: PropsAndState) => propsAndState.usernameInputText,
     (propsAndState: PropsAndState) => propsAndState.otherUserInfos,
     (propsAndState: PropsAndState) => propsAndState.userSearchIndex,
     (propsAndState: PropsAndState) => propsAndState.userInfoInputArray,
     (propsAndState: PropsAndState) =>
       ComposeSubchannel.getParentThreadInfo(propsAndState),
     (propsAndState: PropsAndState) => propsAndState.communityThreadInfo,
     (propsAndState: PropsAndState) => propsAndState.route.params.threadType,
     (
       text: string,
       userInfos: { +[id: string]: AccountUserInfo },
       searchIndex: SearchIndex,
       userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
       parentThreadInfo: ThreadInfo,
       communityThreadInfo: ?ThreadInfo,
       threadType: ?ThreadType,
     ) =>
       getPotentialMemberItems(
         text,
         userInfos,
         searchIndex,
         userInfoInputArray.map(userInfo => userInfo.id),
         parentThreadInfo,
         communityThreadInfo,
         threadType,
       ),
   );
 
   get userSearchResults() {
     return this.userSearchResultsSelector({ ...this.props, ...this.state });
   }
 
   existingThreadsSelector = createSelector(
     (propsAndState: PropsAndState) =>
       ComposeSubchannel.getParentThreadInfo(propsAndState),
     (propsAndState: PropsAndState) => propsAndState.threadInfos,
     (propsAndState: PropsAndState) => propsAndState.userInfoInputArray,
     (
       parentThreadInfo: ThreadInfo,
       threadInfos: { +[id: string]: ThreadInfo },
       userInfoInputArray: $ReadOnlyArray<AccountUserInfo>,
     ) => {
       const userIDs = userInfoInputArray.map(userInfo => userInfo.id);
       if (userIDs.length === 0) {
         return [];
       }
       return _flow(
         _filter(
           (threadInfo: ThreadInfo) =>
             threadInFilterList(threadInfo) &&
             threadInfo.parentThreadID === parentThreadInfo.id &&
             userIDs.every(userID => userIsMember(threadInfo, userID)),
         ),
         _sortBy(
           ([
             'members.length',
             (threadInfo: ThreadInfo) => (threadInfo.name ? 1 : 0),
           ]: $ReadOnlyArray<string | ((threadInfo: ThreadInfo) => mixed)>),
         ),
       )(threadInfos);
     },
   );
 
   get existingThreads() {
     return this.existingThreadsSelector({ ...this.props, ...this.state });
   }
 
   render() {
     let existingThreadsSection = null;
     const { existingThreads, userSearchResults } = this;
     if (existingThreads.length > 0) {
       existingThreadsSection = (
         <View style={this.props.styles.existingThreads}>
           <View style={this.props.styles.existingThreadsRow}>
             <Text style={this.props.styles.existingThreadsLabel}>
-              Existing threads
+              Existing channels
             </Text>
           </View>
           <View style={this.props.styles.existingThreadList}>
             <ThreadList
               threadInfos={existingThreads}
               onSelect={this.onSelectExistingThread}
               itemTextStyle={this.props.styles.listItem}
             />
           </View>
         </View>
       );
     }
     const parentThreadInfo = ComposeSubchannel.getParentThreadInfo(this.props);
     const inputProps = {
       ...tagInputProps,
       onSubmitEditing: this.onPressCreateThread,
     };
     return (
       <View style={this.props.styles.container}>
         <ParentThreadHeader
           parentThreadInfo={parentThreadInfo}
           childThreadType={this.props.route.params.threadType}
         />
         <View style={this.props.styles.userSelectionRow}>
           <Text style={this.props.styles.tagInputLabel}>To: </Text>
           <View style={this.props.styles.tagInputContainer}>
             <TagInput
               value={this.state.userInfoInputArray}
               onChange={this.onChangeTagInput}
               text={this.state.usernameInputText}
               onChangeText={this.setUsernameInputText}
               labelExtractor={this.tagDataLabelExtractor}
               inputProps={inputProps}
               ref={this.tagInputRef}
             />
           </View>
         </View>
         <View style={this.props.styles.userList}>
           <UserList
             userInfos={userSearchResults}
             onSelect={this.onUserSelect}
             itemTextStyle={this.props.styles.listItem}
           />
         </View>
         {existingThreadsSection}
       </View>
     );
   }
 
   tagInputRef = (tagInput: ?BaseTagInput<AccountUserInfo>) => {
     this.tagInput = tagInput;
   };
 
   onChangeTagInput = (userInfoInputArray: $ReadOnlyArray<AccountUserInfo>) => {
     this.setState({ userInfoInputArray });
   };
 
   tagDataLabelExtractor = (userInfo: AccountUserInfo) => userInfo.username;
 
   setUsernameInputText = (text: string) => {
     this.setState({ usernameInputText: text });
   };
 
   onUserSelect = (userID: string) => {
     for (const existingUserInfo of this.state.userInfoInputArray) {
       if (userID === existingUserInfo.id) {
         return;
       }
     }
     const userInfoInputArray = [
       ...this.state.userInfoInputArray,
       this.props.otherUserInfos[userID],
     ];
     this.setState({
       userInfoInputArray,
       usernameInputText: '',
     });
   };
 
   onPressCreateThread = () => {
     if (this.createThreadPressed) {
       return;
     }
     if (this.state.userInfoInputArray.length === 0) {
       Alert.alert(
         'Chatting to yourself?',
-        'Are you sure you want to create a thread containing only yourself?',
+        'Are you sure you want to create a channel containing only yourself?',
         [
           { text: 'Cancel', style: 'cancel' },
           { text: 'Confirm', onPress: this.dispatchNewChatThreadAction },
         ],
         { cancelable: true },
       );
     } else {
       this.dispatchNewChatThreadAction();
     }
   };
 
   dispatchNewChatThreadAction = async () => {
     this.createThreadPressed = true;
     this.props.dispatchActionPromise(
       newThreadActionTypes,
       this.newChatThreadAction(),
     );
   };
 
   async newChatThreadAction() {
     this.setLinkButton(false);
     try {
       const threadTypeParam = this.props.route.params.threadType;
       const threadType =
         threadTypeParam ?? threadTypes.COMMUNITY_SECRET_SUBTHREAD;
       const initialMemberIDs = this.state.userInfoInputArray.map(
         (userInfo: AccountUserInfo) => userInfo.id,
       );
       const parentThreadInfo = ComposeSubchannel.getParentThreadInfo(
         this.props,
       );
       const query = this.props.calendarQuery();
       invariant(
         threadType === 3 ||
           threadType === 4 ||
           threadType === 6 ||
           threadType === 7,
         "Sidebars and communities can't be created from the thread composer",
       );
       const result = await this.props.newThread({
         type: threadType,
         parentThreadID: parentThreadInfo.id,
         initialMemberIDs,
         color: parentThreadInfo.color,
         calendarQuery: query,
       });
       this.waitingOnThreadID = result.newThreadID;
       return result;
     } catch (e) {
       this.createThreadPressed = false;
       this.setLinkButton(true);
       Alert.alert(
         'Unknown error',
         'Uhh... try again?',
         [{ text: 'OK', onPress: this.onUnknownErrorAlertAcknowledged }],
         { cancelable: false },
       );
       throw e;
     }
   }
 
   onErrorAcknowledged = () => {
     invariant(this.tagInput, 'tagInput should be set');
     this.tagInput.focus();
   };
 
   onUnknownErrorAlertAcknowledged = () => {
     this.setState({ usernameInputText: '' }, this.onErrorAcknowledged);
   };
 
   onSelectExistingThread = (threadID: string) => {
     const threadInfo = this.props.threadInfos[threadID];
     this.props.navigateToThread({ threadInfo });
   };
 }
 
 const unboundStyles = {
   container: {
     flex: 1,
   },
   existingThreadList: {
     backgroundColor: 'modalBackground',
     flex: 1,
     paddingRight: 12,
   },
   existingThreads: {
     flex: 1,
   },
   existingThreadsLabel: {
     color: 'modalForegroundSecondaryLabel',
     fontSize: 16,
     paddingLeft: 12,
     textAlign: 'center',
   },
   existingThreadsRow: {
     backgroundColor: 'modalForeground',
     borderBottomWidth: 1,
     borderColor: 'modalForegroundBorder',
     borderTopWidth: 1,
     paddingVertical: 6,
   },
   listItem: {
     color: 'modalForegroundLabel',
   },
   tagInputContainer: {
     flex: 1,
     marginLeft: 8,
     paddingRight: 12,
   },
   tagInputLabel: {
     color: 'modalForegroundSecondaryLabel',
     fontSize: 16,
     paddingLeft: 12,
   },
   userList: {
     backgroundColor: 'modalBackground',
     flex: 1,
     paddingLeft: 35,
     paddingRight: 12,
   },
   userSelectionRow: {
     alignItems: 'center',
     backgroundColor: 'modalForeground',
     borderBottomWidth: 1,
     borderColor: 'modalForegroundBorder',
     flexDirection: 'row',
     paddingVertical: 6,
   },
 };
 
 const ConnectedComposeSubchannel: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedComposeSubchannel(props: BaseProps) {
     const parentThreadInfoID = props.route.params.parentThreadInfo.id;
 
     const reduxParentThreadInfo = useSelector(
       state => threadInfoSelector(state)[parentThreadInfoID],
     );
     const { community } = props.route.params.parentThreadInfo;
     const communityThreadInfo = useSelector(state =>
       community ? threadInfoSelector(state)[community] : null,
     );
     const loadingStatus = useSelector(
       createLoadingStatusSelector(newThreadActionTypes),
     );
     const otherUserInfos = useSelector(userInfoSelectorForPotentialMembers);
     const userSearchIndex = useSelector(userSearchIndexForPotentialMembers);
     const threadInfos = useSelector(threadInfoSelector);
     const styles = useStyles(unboundStyles);
 
     const calendarQuery = useCalendarQuery();
     const navigateToThread = useNavigateToThread();
 
     const dispatchActionPromise = useDispatchActionPromise();
     const callNewThread = useServerCall(newThread);
     return (
       <ComposeSubchannel
         {...props}
         parentThreadInfo={reduxParentThreadInfo}
         communityThreadInfo={communityThreadInfo}
         loadingStatus={loadingStatus}
         otherUserInfos={otherUserInfos}
         userSearchIndex={userSearchIndex}
         threadInfos={threadInfos}
         styles={styles}
         calendarQuery={calendarQuery}
         navigateToThread={navigateToThread}
         dispatchActionPromise={dispatchActionPromise}
         newThread={callNewThread}
       />
     );
   },
 );
 
 export default ConnectedComposeSubchannel;
diff --git a/native/chat/settings/compose-subchannel-modal.react.js b/native/chat/settings/compose-subchannel-modal.react.js
index e743d99da..16132bb74 100644
--- a/native/chat/settings/compose-subchannel-modal.react.js
+++ b/native/chat/settings/compose-subchannel-modal.react.js
@@ -1,150 +1,150 @@
 // @flow
 
 import * as React from 'react';
 import { Text } from 'react-native';
 import IonIcon from 'react-native-vector-icons/Ionicons';
 
 import { threadTypeDescriptions } from 'lib/shared/thread-utils';
 import { type ThreadInfo, threadTypes } from 'lib/types/thread-types';
 
 import Button from '../../components/button.react';
 import Modal from '../../components/modal.react';
 import SWMansionIcon from '../../components/swmansion-icon.react';
 import type { RootNavigationProp } from '../../navigation/root-navigator.react';
 import type { NavigationRoute } from '../../navigation/route-names';
 import { ComposeSubchannelRouteName } from '../../navigation/route-names';
 import { type Colors, useStyles, useColors } from '../../themes/colors';
 
 export type ComposeSubchannelModalParams = {
   presentedFrom: string,
   threadInfo: ThreadInfo,
 };
 
 type BaseProps = {
   +navigation: RootNavigationProp<'ComposeSubchannelModal'>,
   +route: NavigationRoute<'ComposeSubchannelModal'>,
 };
 type Props = {
   ...BaseProps,
   +colors: Colors,
   +styles: typeof unboundStyles,
 };
 class ComposeSubchannelModal extends React.PureComponent<Props> {
   render() {
     return (
       <Modal modalStyle={this.props.styles.modal}>
-        <Text style={this.props.styles.visibility}>Thread type</Text>
+        <Text style={this.props.styles.visibility}>Chat type</Text>
         <Button style={this.props.styles.option} onPress={this.onPressOpen}>
           <SWMansionIcon
             name="globe-1"
             size={32}
             style={this.props.styles.visibilityIcon}
           />
           <Text style={this.props.styles.optionText}>Open</Text>
           <Text style={this.props.styles.optionExplanation}>
             {threadTypeDescriptions[threadTypes.COMMUNITY_OPEN_SUBTHREAD]}
           </Text>
           <IonIcon
             name="ios-arrow-forward"
             size={20}
             style={this.props.styles.forwardIcon}
           />
         </Button>
         <Button style={this.props.styles.option} onPress={this.onPressSecret}>
           <SWMansionIcon
             name="lock-on"
             size={32}
             style={this.props.styles.visibilityIcon}
           />
           <Text style={this.props.styles.optionText}>Secret</Text>
           <Text style={this.props.styles.optionExplanation}>
             {threadTypeDescriptions[threadTypes.COMMUNITY_SECRET_SUBTHREAD]}
           </Text>
           <IonIcon
             name="ios-arrow-forward"
             size={20}
             style={this.props.styles.forwardIcon}
           />
         </Button>
       </Modal>
     );
   }
 
   onPressOpen = () => {
     const threadInfo = this.props.route.params.threadInfo;
     this.props.navigation.navigate({
       name: ComposeSubchannelRouteName,
       params: {
         threadType: threadTypes.COMMUNITY_OPEN_SUBTHREAD,
         parentThreadInfo: threadInfo,
       },
       key:
         `${ComposeSubchannelRouteName}|` +
         `${threadInfo.id}|${threadTypes.COMMUNITY_OPEN_SUBTHREAD}`,
     });
   };
 
   onPressSecret = () => {
     const threadInfo = this.props.route.params.threadInfo;
     this.props.navigation.navigate({
       name: ComposeSubchannelRouteName,
       params: {
         threadType: threadTypes.COMMUNITY_SECRET_SUBTHREAD,
         parentThreadInfo: threadInfo,
       },
       key:
         `${ComposeSubchannelRouteName}|` +
         `${threadInfo.id}|${threadTypes.COMMUNITY_SECRET_SUBTHREAD}`,
     });
   };
 }
 
 const unboundStyles = {
   forwardIcon: {
     color: 'modalForegroundSecondaryLabel',
     paddingLeft: 10,
   },
   modal: {
     flex: 0,
   },
   option: {
     alignItems: 'center',
     flexDirection: 'row',
     paddingHorizontal: 10,
     paddingVertical: 20,
   },
   optionExplanation: {
     color: 'modalBackgroundLabel',
     flex: 1,
     fontSize: 14,
     paddingLeft: 20,
     textAlign: 'center',
   },
   optionText: {
     color: 'modalBackgroundLabel',
     fontSize: 20,
     paddingLeft: 5,
   },
   visibility: {
     color: 'modalBackgroundLabel',
     fontSize: 24,
     textAlign: 'center',
   },
   visibilityIcon: {
     color: 'modalBackgroundLabel',
     paddingRight: 3,
   },
 };
 
 const ConnectedComposeSubchannelModal: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedComposeSubchannelModal(props: BaseProps) {
     const styles = useStyles(unboundStyles);
     const colors = useColors();
 
     return (
       <ComposeSubchannelModal {...props} styles={styles} colors={colors} />
     );
   },
 );
 
 export default ConnectedComposeSubchannelModal;
diff --git a/native/chat/settings/delete-thread.react.js b/native/chat/settings/delete-thread.react.js
index cb5e7bde4..8d6c2f658 100644
--- a/native/chat/settings/delete-thread.react.js
+++ b/native/chat/settings/delete-thread.react.js
@@ -1,318 +1,318 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import {
   Text,
   View,
   TextInput as BaseTextInput,
   ScrollView,
   Alert,
   ActivityIndicator,
 } from 'react-native';
 
 import {
   deleteThreadActionTypes,
   deleteThread,
 } from 'lib/actions/thread-actions';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors';
 import { threadInfoSelector } from 'lib/selectors/thread-selectors';
 import { identifyInvalidatedThreads } from 'lib/shared/thread-utils';
 import type { LoadingStatus } from 'lib/types/loading-types';
 import type { ThreadInfo, LeaveThreadPayload } from 'lib/types/thread-types';
 import {
   useServerCall,
   useDispatchActionPromise,
   type DispatchActionPromise,
 } from 'lib/utils/action-utils';
 
 import Button from '../../components/button.react';
 import TextInput from '../../components/text-input.react';
 import { clearThreadsActionType } from '../../navigation/action-types';
 import {
   NavContext,
   type NavAction,
 } from '../../navigation/navigation-context';
 import type { NavigationRoute } from '../../navigation/route-names';
 import { useSelector } from '../../redux/redux-utils';
 import { type Colors, useColors, useStyles } from '../../themes/colors';
 import type { GlobalTheme } from '../../types/themes';
 import type { ChatNavigationProp } from '../chat.react';
 
 export type DeleteThreadParams = {
   +threadInfo: ThreadInfo,
 };
 
 type BaseProps = {
   +navigation: ChatNavigationProp<'DeleteThread'>,
   +route: NavigationRoute<'DeleteThread'>,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +threadInfo: ?ThreadInfo,
   +loadingStatus: LoadingStatus,
   +activeTheme: ?GlobalTheme,
   +colors: Colors,
   +styles: typeof unboundStyles,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +deleteThread: (
     threadID: string,
     currentAccountPassword: string,
   ) => Promise<LeaveThreadPayload>,
   // withNavContext
   +navDispatch: (action: NavAction) => void,
 };
 type State = {
   +password: string,
 };
 class DeleteThread extends React.PureComponent<Props, State> {
   state: State = {
     password: '',
   };
   mounted = false;
   passwordInput: ?React.ElementRef<typeof BaseTextInput>;
 
   static getThreadInfo(props: Props): ThreadInfo {
     const { threadInfo } = props;
     if (threadInfo) {
       return threadInfo;
     }
     return props.route.params.threadInfo;
   }
 
   componentDidMount() {
     this.mounted = true;
   }
 
   componentWillUnmount() {
     this.mounted = false;
   }
 
   guardedSetState(change, callback) {
     if (this.mounted) {
       this.setState(change, callback);
     }
   }
 
   componentDidUpdate(prevProps: Props) {
     const oldReduxThreadInfo = prevProps.threadInfo;
     const newReduxThreadInfo = this.props.threadInfo;
     if (newReduxThreadInfo && newReduxThreadInfo !== oldReduxThreadInfo) {
       this.props.navigation.setParams({ threadInfo: newReduxThreadInfo });
     }
   }
 
   render() {
     const buttonContent =
       this.props.loadingStatus === 'loading' ? (
         <ActivityIndicator size="small" color="white" />
       ) : (
-        <Text style={this.props.styles.deleteText}>Delete thread</Text>
+        <Text style={this.props.styles.deleteText}>Delete chat</Text>
       );
     const threadInfo = DeleteThread.getThreadInfo(this.props);
     const { panelForegroundTertiaryLabel } = this.props.colors;
     return (
       <ScrollView
         contentContainerStyle={this.props.styles.scrollViewContentContainer}
         style={this.props.styles.scrollView}
       >
         <View>
           <Text style={this.props.styles.warningText}>
-            {`The thread "${threadInfo.uiName}" will be permanently deleted. `}
+            {`The chat "${threadInfo.uiName}" will be permanently deleted. `}
             There is no way to reverse this.
           </Text>
         </View>
         <Text style={this.props.styles.header}>PASSWORD</Text>
         <View style={this.props.styles.section}>
           <TextInput
             style={this.props.styles.input}
             value={this.state.password}
             onChangeText={this.onChangePasswordText}
             placeholder="Password"
             placeholderTextColor={panelForegroundTertiaryLabel}
             secureTextEntry={true}
             textContentType="password"
             autoComplete="password"
             returnKeyType="go"
             onSubmitEditing={this.submitDeletion}
             ref={this.passwordInputRef}
           />
         </View>
         <Button
           onPress={this.submitDeletion}
           style={this.props.styles.deleteButton}
         >
           {buttonContent}
         </Button>
       </ScrollView>
     );
   }
 
   onChangePasswordText = (newPassword: string) => {
     this.guardedSetState({ password: newPassword });
   };
 
   passwordInputRef = (
     passwordInput: ?React.ElementRef<typeof BaseTextInput>,
   ) => {
     this.passwordInput = passwordInput;
   };
 
   focusPasswordInput = () => {
     invariant(this.passwordInput, 'passwordInput should be set');
     this.passwordInput.focus();
   };
 
   submitDeletion = () => {
     this.props.dispatchActionPromise(
       deleteThreadActionTypes,
       this.deleteThread(),
     );
   };
 
   async deleteThread() {
     const threadInfo = DeleteThread.getThreadInfo(this.props);
     const { navDispatch } = this.props;
     navDispatch({
       type: clearThreadsActionType,
       payload: { threadIDs: [threadInfo.id] },
     });
     try {
       const result = await this.props.deleteThread(
         threadInfo.id,
         this.state.password,
       );
       const invalidated = identifyInvalidatedThreads(
         result.updatesResult.newUpdates,
       );
       navDispatch({
         type: clearThreadsActionType,
         payload: { threadIDs: [...invalidated] },
       });
       return result;
     } catch (e) {
       if (
         e.message === 'invalid_credentials' ||
         e.message === 'invalid_parameters'
       ) {
         Alert.alert(
           'Incorrect password',
           'The password you entered is incorrect',
           [{ text: 'OK', onPress: this.onErrorAlertAcknowledged }],
           { cancelable: false },
         );
       } else {
         Alert.alert(
           'Unknown error',
           'Uhh... try again?',
           [{ text: 'OK', onPress: this.onErrorAlertAcknowledged }],
           { cancelable: false },
         );
       }
     }
   }
 
   onErrorAlertAcknowledged = () => {
     this.guardedSetState({ password: '' }, this.focusPasswordInput);
   };
 }
 
 const unboundStyles = {
   deleteButton: {
     backgroundColor: 'redButton',
     borderRadius: 5,
     flex: 1,
     marginHorizontal: 24,
     marginVertical: 12,
     padding: 12,
   },
   deleteText: {
     color: 'white',
     fontSize: 18,
     textAlign: 'center',
   },
   header: {
     color: 'panelBackgroundLabel',
     fontSize: 12,
     fontWeight: '400',
     paddingBottom: 3,
     paddingHorizontal: 24,
   },
   input: {
     color: 'panelForegroundLabel',
     flex: 1,
     fontFamily: 'Arial',
     fontSize: 16,
     paddingVertical: 0,
     borderBottomColor: 'transparent',
   },
   scrollView: {
     backgroundColor: 'panelBackground',
   },
   scrollViewContentContainer: {
     paddingTop: 24,
   },
   section: {
     backgroundColor: 'panelForeground',
     borderBottomWidth: 1,
     borderColor: 'panelForegroundBorder',
     borderTopWidth: 1,
     flexDirection: 'row',
     justifyContent: 'space-between',
     marginBottom: 24,
     paddingHorizontal: 24,
     paddingVertical: 12,
   },
   warningText: {
     color: 'panelForegroundLabel',
     fontSize: 16,
     marginBottom: 24,
     marginHorizontal: 24,
     textAlign: 'center',
   },
 };
 
 const loadingStatusSelector = createLoadingStatusSelector(
   deleteThreadActionTypes,
 );
 
 const ConnectedDeleteThread: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedDeleteThread(props: BaseProps) {
     const threadID = props.route.params.threadInfo.id;
     const threadInfo = useSelector(
       state => threadInfoSelector(state)[threadID],
     );
 
     const loadingStatus = useSelector(loadingStatusSelector);
     const activeTheme = useSelector(state => state.globalThemeInfo.activeTheme);
 
     const colors = useColors();
     const styles = useStyles(unboundStyles);
 
     const dispatchActionPromise = useDispatchActionPromise();
     const callDeleteThread = useServerCall(deleteThread);
 
     const navContext = React.useContext(NavContext);
     invariant(navContext, 'NavContext should be set in DeleteThread');
     const navDispatch = navContext.dispatch;
 
     return (
       <DeleteThread
         {...props}
         threadInfo={threadInfo}
         loadingStatus={loadingStatus}
         activeTheme={activeTheme}
         colors={colors}
         styles={styles}
         dispatchActionPromise={dispatchActionPromise}
         deleteThread={callDeleteThread}
         navDispatch={navDispatch}
       />
     );
   },
 );
 
 export default ConnectedDeleteThread;
diff --git a/native/chat/settings/thread-settings-delete-thread.react.js b/native/chat/settings/thread-settings-delete-thread.react.js
index 8ab2cf2ce..6926776e0 100644
--- a/native/chat/settings/thread-settings-delete-thread.react.js
+++ b/native/chat/settings/thread-settings-delete-thread.react.js
@@ -1,64 +1,64 @@
 // @flow
 
 import * as React from 'react';
 import { Text, View } from 'react-native';
 
 import type { ThreadInfo } from 'lib/types/thread-types';
 
 import Button from '../../components/button.react';
 import { DeleteThreadRouteName } from '../../navigation/route-names';
 import { useColors, useStyles } from '../../themes/colors';
 import type { ViewStyle } from '../../types/styles';
 import type { ThreadSettingsNavigate } from './thread-settings.react';
 
 type Props = {
   +threadInfo: ThreadInfo,
   +navigate: ThreadSettingsNavigate,
   +buttonStyle: ViewStyle,
 };
 function ThreadSettingsDeleteThread(props: Props): React.Node {
   const { navigate, threadInfo } = props;
   const onPress = React.useCallback(() => {
     navigate({
       name: DeleteThreadRouteName,
       params: { threadInfo },
       key: `${DeleteThreadRouteName}${threadInfo.id}`,
     });
   }, [navigate, threadInfo]);
 
   const colors = useColors();
   const { panelIosHighlightUnderlay } = colors;
 
   const styles = useStyles(unboundStyles);
   return (
     <View style={styles.container}>
       <Button
         onPress={onPress}
         style={[styles.button, props.buttonStyle]}
         iosFormat="highlight"
         iosHighlightUnderlayColor={panelIosHighlightUnderlay}
       >
-        <Text style={styles.text}>Delete thread...</Text>
+        <Text style={styles.text}>Delete chat...</Text>
       </Button>
     </View>
   );
 }
 
 const unboundStyles = {
   button: {
     flexDirection: 'row',
     paddingHorizontal: 12,
     paddingVertical: 10,
   },
   container: {
     backgroundColor: 'panelForeground',
     paddingHorizontal: 12,
   },
   text: {
     color: 'redText',
     flex: 1,
     fontSize: 16,
   },
 };
 
 export default ThreadSettingsDeleteThread;
diff --git a/native/chat/settings/thread-settings-leave-thread.react.js b/native/chat/settings/thread-settings-leave-thread.react.js
index c5817d4d3..e3e6eadb2 100644
--- a/native/chat/settings/thread-settings-leave-thread.react.js
+++ b/native/chat/settings/thread-settings-leave-thread.react.js
@@ -1,178 +1,178 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { Text, Alert, ActivityIndicator, View } from 'react-native';
 
 import {
   leaveThreadActionTypes,
   leaveThread,
 } from 'lib/actions/thread-actions';
 import { createLoadingStatusSelector } from 'lib/selectors/loading-selectors';
 import { otherUsersButNoOtherAdmins } from 'lib/selectors/thread-selectors';
 import { identifyInvalidatedThreads } from 'lib/shared/thread-utils';
 import type { LoadingStatus } from 'lib/types/loading-types';
 import type { ThreadInfo, LeaveThreadPayload } from 'lib/types/thread-types';
 import {
   type DispatchActionPromise,
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils';
 
 import Button from '../../components/button.react';
 import { clearThreadsActionType } from '../../navigation/action-types';
 import {
   NavContext,
   type NavContextType,
 } from '../../navigation/navigation-context';
 import { useSelector } from '../../redux/redux-utils';
 import { type Colors, useColors, useStyles } from '../../themes/colors';
 import type { ViewStyle } from '../../types/styles';
 
 type BaseProps = {
   +threadInfo: ThreadInfo,
   +buttonStyle: ViewStyle,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +loadingStatus: LoadingStatus,
   +otherUsersButNoOtherAdmins: boolean,
   +colors: Colors,
   +styles: typeof unboundStyles,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +leaveThread: (threadID: string) => Promise<LeaveThreadPayload>,
   // withNavContext
   +navContext: ?NavContextType,
 };
 class ThreadSettingsLeaveThread extends React.PureComponent<Props> {
   render() {
     const {
       panelIosHighlightUnderlay,
       panelForegroundSecondaryLabel,
     } = this.props.colors;
     const loadingIndicator =
       this.props.loadingStatus === 'loading' ? (
         <ActivityIndicator size="small" color={panelForegroundSecondaryLabel} />
       ) : null;
     return (
       <View style={this.props.styles.container}>
         <Button
           onPress={this.onPress}
           style={[this.props.styles.button, this.props.buttonStyle]}
           iosFormat="highlight"
           iosHighlightUnderlayColor={panelIosHighlightUnderlay}
         >
-          <Text style={this.props.styles.text}>Leave thread...</Text>
+          <Text style={this.props.styles.text}>Leave chat...</Text>
           {loadingIndicator}
         </Button>
       </View>
     );
   }
 
   onPress = () => {
     if (this.props.otherUsersButNoOtherAdmins) {
       Alert.alert(
         'Need another admin',
         'Make somebody else an admin before you leave!',
         undefined,
         { cancelable: true },
       );
       return;
     }
 
     Alert.alert(
       'Confirm action',
-      'Are you sure you want to leave this thread?',
+      'Are you sure you want to leave this chat?',
       [
         { text: 'Cancel', style: 'cancel' },
         { text: 'OK', onPress: this.onConfirmLeaveThread },
       ],
       { cancelable: true },
     );
   };
 
   onConfirmLeaveThread = () => {
     this.props.dispatchActionPromise(
       leaveThreadActionTypes,
       this.leaveThread(),
     );
   };
 
   async leaveThread() {
     const threadID = this.props.threadInfo.id;
     const { navContext } = this.props;
     invariant(navContext, 'navContext should exist in leaveThread');
     navContext.dispatch({
       type: clearThreadsActionType,
       payload: { threadIDs: [threadID] },
     });
     try {
       const result = await this.props.leaveThread(threadID);
       const invalidated = identifyInvalidatedThreads(
         result.updatesResult.newUpdates,
       );
       navContext.dispatch({
         type: clearThreadsActionType,
         payload: { threadIDs: [...invalidated] },
       });
       return result;
     } catch (e) {
       Alert.alert('Unknown error', 'Uhh... try again?', undefined, {
         cancelable: true,
       });
       throw e;
     }
   }
 }
 
 const unboundStyles = {
   button: {
     flexDirection: 'row',
     paddingHorizontal: 12,
     paddingVertical: 10,
   },
   container: {
     backgroundColor: 'panelForeground',
     paddingHorizontal: 12,
   },
   text: {
     color: 'redText',
     flex: 1,
     fontSize: 16,
   },
 };
 
 const loadingStatusSelector = createLoadingStatusSelector(
   leaveThreadActionTypes,
 );
 
 const ConnectedThreadSettingsLeaveThread: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedThreadSettingsLeaveThread(props: BaseProps) {
     const loadingStatus = useSelector(loadingStatusSelector);
     const otherUsersButNoOtherAdminsValue = useSelector(
       otherUsersButNoOtherAdmins(props.threadInfo.id),
     );
     const colors = useColors();
     const styles = useStyles(unboundStyles);
     const dispatchActionPromise = useDispatchActionPromise();
     const callLeaveThread = useServerCall(leaveThread);
     const navContext = React.useContext(NavContext);
     return (
       <ThreadSettingsLeaveThread
         {...props}
         loadingStatus={loadingStatus}
         otherUsersButNoOtherAdmins={otherUsersButNoOtherAdminsValue}
         colors={colors}
         styles={styles}
         dispatchActionPromise={dispatchActionPromise}
         leaveThread={callLeaveThread}
         navContext={navContext}
       />
     );
   },
 );
 
 export default ConnectedThreadSettingsLeaveThread;
diff --git a/native/chat/settings/thread-settings-member-tooltip-modal.react.js b/native/chat/settings/thread-settings-member-tooltip-modal.react.js
index 03a971063..5739f663d 100644
--- a/native/chat/settings/thread-settings-member-tooltip-modal.react.js
+++ b/native/chat/settings/thread-settings-member-tooltip-modal.react.js
@@ -1,106 +1,106 @@
 // @flow
 
 import * as React from 'react';
 import { Alert } from 'react-native';
 
 import {
   removeUsersFromThread,
   changeThreadMemberRoles,
 } from 'lib/actions/thread-actions';
 import {
   memberIsAdmin,
   removeMemberFromThread,
   switchMemberAdminRoleInThread,
 } from 'lib/shared/thread-utils';
 import { stringForUser } from 'lib/shared/user-utils';
 import type { ThreadInfo, RelativeMemberInfo } from 'lib/types/thread-types';
 import type { DispatchFunctions, ActionFunc } from 'lib/utils/action-utils';
 
 import {
   createTooltip,
   type TooltipParams,
   type TooltipRoute,
   type BaseTooltipProps,
 } from '../../navigation/tooltip.react';
 import ThreadSettingsMemberTooltipButton from './thread-settings-member-tooltip-button.react';
 
 export type ThreadSettingsMemberTooltipModalParams = TooltipParams<{
   +memberInfo: RelativeMemberInfo,
   +threadInfo: ThreadInfo,
 }>;
 
 function onRemoveUser(
   route: TooltipRoute<'ThreadSettingsMemberTooltipModal'>,
   dispatchFunctions: DispatchFunctions,
   bindServerCall: <F>(serverCall: ActionFunc<F>) => F,
 ) {
   const { memberInfo, threadInfo } = route.params;
   const boundRemoveUsersFromThread = bindServerCall(removeUsersFromThread);
   const onConfirmRemoveUser = () =>
     removeMemberFromThread(
       threadInfo,
       memberInfo,
       dispatchFunctions.dispatchActionPromise,
       boundRemoveUsersFromThread,
     );
 
   const userText = stringForUser(memberInfo);
   Alert.alert(
     'Confirm removal',
-    `Are you sure you want to remove ${userText} from this thread?`,
+    `Are you sure you want to remove ${userText} from this chat?`,
     [
       { text: 'Cancel', style: 'cancel' },
       { text: 'OK', onPress: onConfirmRemoveUser },
     ],
     { cancelable: true },
   );
 }
 
 function onToggleAdmin(
   route: TooltipRoute<'ThreadSettingsMemberTooltipModal'>,
   dispatchFunctions: DispatchFunctions,
   bindServerCall: <F>(serverCall: ActionFunc<F>) => F,
 ) {
   const { memberInfo, threadInfo } = route.params;
   const isCurrentlyAdmin = memberIsAdmin(memberInfo, threadInfo);
   const boundChangeThreadMemberRoles = bindServerCall(changeThreadMemberRoles);
   const onConfirmMakeAdmin = () =>
     switchMemberAdminRoleInThread(
       threadInfo,
       memberInfo,
       isCurrentlyAdmin,
       dispatchFunctions.dispatchActionPromise,
       boundChangeThreadMemberRoles,
     );
 
   const userText = stringForUser(memberInfo);
   const actionClause = isCurrentlyAdmin
     ? `remove ${userText} as an admin`
     : `make ${userText} an admin`;
   Alert.alert(
     'Confirm action',
-    `Are you sure you want to ${actionClause} of this thread?`,
+    `Are you sure you want to ${actionClause} of this chat?`,
     [
       { text: 'Cancel', style: 'cancel' },
       { text: 'OK', onPress: onConfirmMakeAdmin },
     ],
     { cancelable: true },
   );
 }
 
 const spec = {
   entries: [
     { id: 'remove_user', text: 'Remove user', onPress: onRemoveUser },
     { id: 'remove_admin', text: 'Remove admin', onPress: onToggleAdmin },
     { id: 'make_admin', text: 'Make admin', onPress: onToggleAdmin },
   ],
 };
 
 const ThreadSettingsMemberTooltipModal: React.ComponentType<
   BaseTooltipProps<'ThreadSettingsMemberTooltipModal'>,
 > = createTooltip<'ThreadSettingsMemberTooltipModal'>(
   ThreadSettingsMemberTooltipButton,
   spec,
 );
 
 export default ThreadSettingsMemberTooltipModal;
diff --git a/native/chat/settings/thread-settings-promote-sidebar.react.js b/native/chat/settings/thread-settings-promote-sidebar.react.js
index baafc9541..6ddf44139 100644
--- a/native/chat/settings/thread-settings-promote-sidebar.react.js
+++ b/native/chat/settings/thread-settings-promote-sidebar.react.js
@@ -1,114 +1,114 @@
 // @flow
 
 import * as React from 'react';
 import { Text, ActivityIndicator, View, Alert } from 'react-native';
 
 import { usePromoteSidebar } from 'lib/hooks/promote-sidebar.react';
 import type { LoadingStatus } from 'lib/types/loading-types';
 import type { ThreadInfo } from 'lib/types/thread-types';
 
 import Button from '../../components/button.react';
 import { type Colors, useColors, useStyles } from '../../themes/colors';
 import type { ViewStyle } from '../../types/styles';
 
 type BaseProps = {
   +threadInfo: ThreadInfo,
   +buttonStyle: ViewStyle,
 };
 type Props = {
   ...BaseProps,
   +loadingStatus: LoadingStatus,
   +colors: Colors,
   +styles: typeof unboundStyles,
   +promoteSidebar: () => mixed,
 };
 class ThreadSettingsPromoteSidebar extends React.PureComponent<Props> {
   onClick = () => {
     Alert.alert(
       'Are you sure?',
-      'Promoting a sidebar to a full thread cannot be undone.',
+      'Promoting a sidebar to a channel cannot be undone.',
       [
         {
           text: 'Cancel',
           style: 'cancel',
         },
         {
           text: 'Yes',
           onPress: this.props.promoteSidebar,
         },
       ],
     );
   };
 
   render() {
     const {
       panelIosHighlightUnderlay,
       panelForegroundSecondaryLabel,
     } = this.props.colors;
     const loadingIndicator =
       this.props.loadingStatus === 'loading' ? (
         <ActivityIndicator size="small" color={panelForegroundSecondaryLabel} />
       ) : null;
 
     return (
       <View style={this.props.styles.container}>
         <Button
           onPress={this.onClick}
           style={[this.props.styles.button, this.props.buttonStyle]}
           iosFormat="highlight"
           iosHighlightUnderlayColor={panelIosHighlightUnderlay}
         >
-          <Text style={this.props.styles.text}>Promote to full thread</Text>
+          <Text style={this.props.styles.text}>Promote to channel</Text>
           {loadingIndicator}
         </Button>
       </View>
     );
   }
 }
 
 const unboundStyles = {
   button: {
     flexDirection: 'row',
     paddingHorizontal: 12,
     paddingVertical: 10,
   },
   container: {
     backgroundColor: 'panelForeground',
     paddingHorizontal: 12,
   },
   text: {
     color: 'panelForegroundSecondaryLabel',
     flex: 1,
     fontSize: 16,
   },
 };
 
 const onError = () => {
   Alert.alert('Unknown error', 'Uhh... try again?', undefined, {
     cancelable: true,
   });
 };
 
 const ConnectedThreadSettingsPromoteSidebar: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedThreadSettingsPromoteSidebar(props: BaseProps) {
     const { threadInfo } = props;
     const colors = useColors();
     const styles = useStyles(unboundStyles);
     const { onPromoteSidebar, loading } = usePromoteSidebar(
       threadInfo,
       onError,
     );
 
     return (
       <ThreadSettingsPromoteSidebar
         {...props}
         colors={colors}
         styles={styles}
         promoteSidebar={onPromoteSidebar}
         loadingStatus={loading}
       />
     );
   },
 );
 
 export default ConnectedThreadSettingsPromoteSidebar;
diff --git a/native/chat/settings/thread-settings-push-notifs.react.js b/native/chat/settings/thread-settings-push-notifs.react.js
index e1a953317..281c70c16 100644
--- a/native/chat/settings/thread-settings-push-notifs.react.js
+++ b/native/chat/settings/thread-settings-push-notifs.react.js
@@ -1,178 +1,178 @@
 // @flow
 
 import * as React from 'react';
 import { View, Switch, TouchableOpacity, Platform } from 'react-native';
 import Alert from 'react-native/Libraries/Alert/Alert';
 import Linking from 'react-native/Libraries/Linking/Linking';
 
 import {
   updateSubscriptionActionTypes,
   updateSubscription,
 } from 'lib/actions/user-actions';
 import type {
   SubscriptionUpdateRequest,
   SubscriptionUpdateResult,
 } from 'lib/types/subscription-types';
 import { type ThreadInfo } from 'lib/types/thread-types';
 import type { DispatchActionPromise } from 'lib/utils/action-utils';
 import {
   useServerCall,
   useDispatchActionPromise,
 } from 'lib/utils/action-utils';
 
 import { SingleLine } from '../../components/single-line.react';
 import SWMansionIcon from '../../components/swmansion-icon.react';
 import { useSelector } from '../../redux/redux-utils';
 import { useStyles } from '../../themes/colors';
 
 type BaseProps = {
   +threadInfo: ThreadInfo,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +styles: typeof unboundStyles,
   // Redux dispatch functions
   +dispatchActionPromise: DispatchActionPromise,
   // async functions that hit server APIs
   +hasPushPermissions: boolean,
   +updateSubscription: (
     subscriptionUpdate: SubscriptionUpdateRequest,
   ) => Promise<SubscriptionUpdateResult>,
 };
 type State = {
   +currentValue: boolean,
 };
 class ThreadSettingsPushNotifs extends React.PureComponent<Props, State> {
   constructor(props: Props) {
     super(props);
     this.state = {
       currentValue: props.threadInfo.currentUser.subscription.pushNotifs,
     };
   }
 
   render() {
     const componentLabel = 'Push notifs';
     let notificationsSettingsLinkingIcon = undefined;
     if (!this.props.hasPushPermissions) {
       notificationsSettingsLinkingIcon = (
         <TouchableOpacity
           onPress={this.onNotificationsSettingsLinkingIconPress}
         >
           <View style={this.props.styles.infoIcon}>
             <SWMansionIcon name="info-circle" size={25} color="gray" />
           </View>
         </TouchableOpacity>
       );
     }
     return (
       <View style={this.props.styles.row}>
         <SingleLine style={this.props.styles.label} adjustsFontSizeToFit={true}>
           {componentLabel}
         </SingleLine>
         {notificationsSettingsLinkingIcon}
         <View style={this.props.styles.currentValue}>
           <Switch
             value={this.state.currentValue}
             onValueChange={this.onValueChange}
             disabled={!this.props.hasPushPermissions}
           />
         </View>
       </View>
     );
   }
 
   onValueChange = (value: boolean) => {
     this.setState({ currentValue: value });
     this.props.dispatchActionPromise(
       updateSubscriptionActionTypes,
       this.props.updateSubscription({
         threadID: this.props.threadInfo.id,
         updatedFields: {
           pushNotifs: value,
         },
       }),
     );
   };
 
   onNotificationsSettingsLinkingIconPress = () => {
     const alertTitle =
       Platform.OS === 'ios'
         ? 'Need notif permissions'
         : 'Unable to initialize notifs';
     let alertMessage;
     if (Platform.OS === 'ios' && this.state.currentValue) {
       alertMessage =
-        'Notifs for this thread are enabled, but cannot be delivered ' +
+        'Notifs for this chat are enabled, but cannot be delivered ' +
         'to this device because you haven’t granted notif permissions to Comm. ' +
         'Please enable them in Settings App → Notifications → Comm';
     } else if (Platform.OS === 'ios') {
       alertMessage =
-        'In order to enable push notifs for this thread, ' +
+        'In order to enable push notifs for this chat, ' +
         'you need to first grant notif permissions to Comm. ' +
         'Please enable them in Settings App → Notifications → Comm';
     } else {
       alertMessage =
         'Please check your network connection, make sure Google Play ' +
         'services are installed and enabled, and confirm that your Google ' +
         'Play credentials are valid in the Google Play Store.';
     }
     Alert.alert(alertTitle, alertMessage, [
       {
         text: 'Go to settings',
         onPress: () => Linking.openSettings(),
       },
       {
         text: 'Cancel',
         style: 'cancel',
       },
     ]);
   };
 }
 
 const unboundStyles = {
   currentValue: {
     alignItems: 'flex-end',
     margin: 0,
     paddingLeft: 4,
     paddingRight: 0,
     paddingVertical: 0,
   },
   label: {
     color: 'panelForegroundTertiaryLabel',
     fontSize: 16,
     flex: 1,
   },
   row: {
     alignItems: 'center',
     backgroundColor: 'panelForeground',
     flexDirection: 'row',
     paddingHorizontal: 24,
     paddingVertical: 3,
   },
   infoIcon: {
     paddingRight: 20,
   },
 };
 
 const ConnectedThreadSettingsPushNotifs: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedThreadSettingsPushNotifs(props: BaseProps) {
     const styles = useStyles(unboundStyles);
     const dispatchActionPromise = useDispatchActionPromise();
     const callUpdateSubscription = useServerCall(updateSubscription);
     const hasPushPermissions = useSelector(
       state => state.deviceToken !== null && state.deviceToken !== undefined,
     );
     return (
       <ThreadSettingsPushNotifs
         {...props}
         styles={styles}
         dispatchActionPromise={dispatchActionPromise}
         updateSubscription={callUpdateSubscription}
         hasPushPermissions={hasPushPermissions}
       />
     );
   },
 );
 
 export default ConnectedThreadSettingsPushNotifs;
diff --git a/native/chat/thread-screen-pruner.react.js b/native/chat/thread-screen-pruner.react.js
index 6cd384b5c..10b2a75a4 100644
--- a/native/chat/thread-screen-pruner.react.js
+++ b/native/chat/thread-screen-pruner.react.js
@@ -1,84 +1,84 @@
 // @flow
 
 import * as React from 'react';
 import { Alert } from 'react-native';
 
 import { threadIsPending } from 'lib/shared/thread-utils';
 
 import { clearThreadsActionType } from '../navigation/action-types';
 import { useActiveThread } from '../navigation/nav-selectors';
 import { NavContext } from '../navigation/navigation-context';
 import {
   getStateFromNavigatorRoute,
   getThreadIDFromRoute,
 } from '../navigation/navigation-utils';
 import { useSelector } from '../redux/redux-utils';
 import type { AppState } from '../redux/state-types';
 
 const ThreadScreenPruner: React.ComponentType<{}> = React.memo<{}>(
   function ThreadScreenPruner() {
     const rawThreadInfos = useSelector(
       (state: AppState) => state.threadStore.threadInfos,
     );
 
     const navContext = React.useContext(NavContext);
 
     const chatRoute = React.useMemo(() => {
       if (!navContext) {
         return null;
       }
       const { state } = navContext;
       const appState = getStateFromNavigatorRoute(state.routes[0]);
       const tabState = getStateFromNavigatorRoute(appState.routes[0]);
       return getStateFromNavigatorRoute(tabState.routes[1]);
     }, [navContext]);
 
     const inStackThreadIDs = React.useMemo(() => {
       const threadIDs = new Set();
       if (!chatRoute) {
         return threadIDs;
       }
       for (const route of chatRoute.routes) {
         const threadID = getThreadIDFromRoute(route);
         if (threadID && !threadIsPending(threadID)) {
           threadIDs.add(threadID);
         }
       }
       return threadIDs;
     }, [chatRoute]);
 
     const pruneThreadIDs = React.useMemo(() => {
       const threadIDs = [];
       for (const threadID of inStackThreadIDs) {
         if (!rawThreadInfos[threadID]) {
           threadIDs.push(threadID);
         }
       }
       return threadIDs;
     }, [inStackThreadIDs, rawThreadInfos]);
 
     const activeThreadID = useActiveThread();
 
     React.useEffect(() => {
       if (pruneThreadIDs.length === 0 || !navContext) {
         return;
       }
       if (activeThreadID && pruneThreadIDs.includes(activeThreadID)) {
         Alert.alert(
-          'Thread invalidated',
-          'You no longer have permission to view this thread :(',
+          'Chat invalidated',
+          'You no longer have permission to view this chat :(',
           [{ text: 'OK' }],
           { cancelable: true },
         );
       }
       navContext.dispatch({
         type: clearThreadsActionType,
         payload: { threadIDs: pruneThreadIDs },
       });
     }, [pruneThreadIDs, navContext, activeThreadID]);
 
     return null;
   },
 );
 
 export default ThreadScreenPruner;
diff --git a/native/components/color-selector.react.js b/native/components/color-selector.react.js
index aee519a24..543c10265 100644
--- a/native/components/color-selector.react.js
+++ b/native/components/color-selector.react.js
@@ -1,103 +1,103 @@
 // @flow
 
 import * as React from 'react';
 import { Text, TouchableOpacity, View, StyleSheet } from 'react-native';
 import tinycolor from 'tinycolor2';
 
 import { selectedThreadColors } from 'lib/shared/thread-utils';
 
 import ColorSelectorButton from './color-selector-button.react';
 
 type ColorSelectorProps = {
   +currentColor: string,
   +windowWidth: number,
   +onColorSelected: (hex: string) => void,
 };
 function ColorSelector(props: ColorSelectorProps): React.Node {
   const { currentColor, onColorSelected } = props;
   const [pendingColor, setPendingColor] = React.useState(currentColor);
 
   const colorSelectorButtons = React.useMemo(
     () =>
       selectedThreadColors.map(color => (
         <ColorSelectorButton
           key={color}
           color={color}
           pendingColor={pendingColor}
           setPendingColor={setPendingColor}
         />
       )),
     [pendingColor],
   );
 
   const firstRow = React.useMemo(
     () => colorSelectorButtons.slice(0, colorSelectorButtons.length / 2),
     [colorSelectorButtons],
   );
 
   const secondRow = React.useMemo(
     () => colorSelectorButtons.slice(colorSelectorButtons.length / 2),
     [colorSelectorButtons],
   );
 
   const saveButtonDisabled = tinycolor.equals(currentColor, pendingColor);
   const saveButtonStyle = React.useMemo(
     () => [
       styles.saveButton,
       {
         backgroundColor: saveButtonDisabled ? '#404040' : `#${pendingColor}`,
         width: 0.75 * props.windowWidth,
       },
     ],
     [saveButtonDisabled, pendingColor, props.windowWidth],
   );
 
   const onColorSplotchSaved = React.useCallback(() => {
     onColorSelected(`#${pendingColor}`);
   }, [onColorSelected, pendingColor]);
 
   return (
     <View style={styles.container}>
-      <Text style={styles.header}>Select thread color</Text>
+      <Text style={styles.header}>Select chat color</Text>
       <View style={styles.colorButtons}>{firstRow}</View>
       <View style={styles.colorButtons}>{secondRow}</View>
       <TouchableOpacity
         style={saveButtonStyle}
         onPress={onColorSplotchSaved}
         disabled={saveButtonDisabled}
       >
         <Text style={styles.saveButtonText}>Save</Text>
       </TouchableOpacity>
     </View>
   );
 }
 
 const styles = StyleSheet.create({
   colorButtons: {
     flexDirection: 'row',
     justifyContent: 'space-evenly',
   },
   container: {
     alignItems: 'center',
     flex: 1,
   },
   header: {
     color: 'white',
     fontSize: 24,
     fontWeight: 'bold',
     marginBottom: 10,
     marginTop: 20,
   },
   saveButton: {
     alignItems: 'center',
     borderRadius: 5,
     margin: 10,
     padding: 10,
   },
   saveButtonText: {
     color: 'white',
     fontSize: 16,
   },
 });
 
 export default ColorSelector;
diff --git a/native/components/thread-list.react.js b/native/components/thread-list.react.js
index 34d6f05b0..200a130c3 100644
--- a/native/components/thread-list.react.js
+++ b/native/components/thread-list.react.js
@@ -1,151 +1,151 @@
 // @flow
 
 import invariant from 'invariant';
 import * as React from 'react';
 import { FlatList, TextInput } from 'react-native';
 import { createSelector } from 'reselect';
 
 import SearchIndex from 'lib/shared/search-index';
 import type { ThreadInfo } from 'lib/types/thread-types';
 
 import {
   type IndicatorStyle,
   useStyles,
   useIndicatorStyle,
 } from '../themes/colors';
 import type { ViewStyle, TextStyle } from '../types/styles';
 import { waitForModalInputFocus } from '../utils/timers';
 import Search from './search.react';
 import ThreadListThread from './thread-list-thread.react';
 
 type BaseProps = {
   +threadInfos: $ReadOnlyArray<ThreadInfo>,
   +onSelect: (threadID: string) => void,
   +itemStyle?: ViewStyle,
   +itemTextStyle?: TextStyle,
   +searchIndex?: SearchIndex,
 };
 type Props = {
   ...BaseProps,
   // Redux state
   +styles: typeof unboundStyles,
   +indicatorStyle: IndicatorStyle,
 };
 type State = {
   +searchText: string,
   +searchResults: Set<string>,
 };
 type PropsAndState = { ...Props, ...State };
 class ThreadList extends React.PureComponent<Props, State> {
   state: State = {
     searchText: '',
     searchResults: new Set(),
   };
   textInput: ?React.ElementRef<typeof TextInput>;
 
   listDataSelector = createSelector(
     (propsAndState: PropsAndState) => propsAndState.threadInfos,
     (propsAndState: PropsAndState) => propsAndState.searchText,
     (propsAndState: PropsAndState) => propsAndState.searchResults,
     (propsAndState: PropsAndState) => propsAndState.itemStyle,
     (propsAndState: PropsAndState) => propsAndState.itemTextStyle,
     (
       threadInfos: $ReadOnlyArray<ThreadInfo>,
       text: string,
       searchResults: Set<string>,
     ) =>
       text
         ? threadInfos.filter(threadInfo => searchResults.has(threadInfo.id))
         : // We spread to make sure the result of this selector updates when
           // any input param (namely itemStyle or itemTextStyle) changes
           [...threadInfos],
   );
 
   get listData() {
     return this.listDataSelector({ ...this.props, ...this.state });
   }
 
   render() {
     let searchBar = null;
     if (this.props.searchIndex) {
       searchBar = (
         <Search
           searchText={this.state.searchText}
           onChangeText={this.onChangeSearchText}
           containerStyle={this.props.styles.search}
-          placeholder="Search threads"
+          placeholder="Search chats"
           ref={this.searchRef}
         />
       );
     }
     return (
       <React.Fragment>
         {searchBar}
         <FlatList
           data={this.listData}
           renderItem={this.renderItem}
           keyExtractor={ThreadList.keyExtractor}
           getItemLayout={ThreadList.getItemLayout}
           keyboardShouldPersistTaps="handled"
           initialNumToRender={20}
           indicatorStyle={this.props.indicatorStyle}
         />
       </React.Fragment>
     );
   }
 
   static keyExtractor = (threadInfo: ThreadInfo) => {
     return threadInfo.id;
   };
 
   renderItem = (row: { item: ThreadInfo, ... }) => {
     return (
       <ThreadListThread
         threadInfo={row.item}
         onSelect={this.props.onSelect}
         style={this.props.itemStyle}
         textStyle={this.props.itemTextStyle}
       />
     );
   };
 
   static getItemLayout = (data: ?$ReadOnlyArray<ThreadInfo>, index: number) => {
     return { length: 24, offset: 24 * index, index };
   };
 
   onChangeSearchText = (searchText: string) => {
     invariant(this.props.searchIndex, 'should be set');
     const results = this.props.searchIndex.getSearchResults(searchText);
     this.setState({ searchText, searchResults: new Set(results) });
   };
 
   searchRef = async (textInput: ?React.ElementRef<typeof TextInput>) => {
     this.textInput = textInput;
     if (!textInput) {
       return;
     }
     await waitForModalInputFocus();
     if (this.textInput) {
       this.textInput.focus();
     }
   };
 }
 
 const unboundStyles = {
   search: {
     marginBottom: 8,
   },
 };
 
 const ConnectedThreadList: React.ComponentType<BaseProps> = React.memo<BaseProps>(
   function ConnectedThreadList(props: BaseProps) {
     const styles = useStyles(unboundStyles);
     const indicatorStyle = useIndicatorStyle();
 
     return (
       <ThreadList {...props} styles={styles} indicatorStyle={indicatorStyle} />
     );
   },
 );
 
 export default ConnectedThreadList;