diff --git a/lib/handlers/initial-state-sharing-handler.react.js b/lib/handlers/initial-state-sharing-handler.react.js
new file mode 100644
index 000000000..ebc2aeec1
--- /dev/null
+++ b/lib/handlers/initial-state-sharing-handler.react.js
@@ -0,0 +1,89 @@
+// @flow
+
+import invariant from 'invariant';
+import * as React from 'react';
+
+import { getOwnPeerDevices } from '../selectors/user-selectors.js';
+import {
+  dmOperationSpecificationTypes,
+  getCreateThickRawThreadInfoInputFromThreadInfo,
+} from '../shared/dm-ops/dm-op-utils.js';
+import { useProcessAndSendDMOperation } from '../shared/dm-ops/process-dm-ops.js';
+import { IdentityClientContext } from '../shared/identity-client-context.js';
+import { values } from '../utils/objects.js';
+import { useSelector } from '../utils/redux-utils.js';
+
+function InitialStateSharingHandler(): React.Node {
+  const userDeviceIDs = useSelector(state =>
+    getOwnPeerDevices(state).map(peer => peer.deviceID),
+  );
+  const threadInfos = useSelector(state => state.threadStore.threadInfos);
+  const viewerID = useSelector(
+    state => state.currentUserInfo && state.currentUserInfo.id,
+  );
+  const identityContext = React.useContext(IdentityClientContext);
+  const processAndSendDMOperation = useProcessAndSendDMOperation();
+
+  const deviceIDs = React.useRef<$ReadOnlySet<string>>(new Set(userDeviceIDs));
+
+  React.useEffect(() => {
+    void (async () => {
+      const oldDeviceIDs = deviceIDs.current;
+      const newDeviceIDs = new Set(userDeviceIDs);
+      deviceIDs.current = newDeviceIDs;
+
+      invariant(identityContext, 'Identity context should be set');
+      const authMetadata = await identityContext.getAuthMetadata();
+      if (authMetadata.deviceID !== userDeviceIDs[0] || !viewerID) {
+        return;
+      }
+
+      const recipients = new Set<string>();
+      for (const deviceID of newDeviceIDs) {
+        if (!oldDeviceIDs.has(deviceID)) {
+          recipients.add(deviceID);
+        }
+      }
+
+      if (recipients.size === 0) {
+        return;
+      }
+
+      for (const threadInfo of values(threadInfos)) {
+        if (!threadInfo.thick) {
+          continue;
+        }
+
+        const existingThreadDetails =
+          getCreateThickRawThreadInfoInputFromThreadInfo(threadInfo);
+        const operation = {
+          type: 'add_viewer_to_thread_members',
+          existingThreadDetails,
+          editorID: viewerID,
+          time: threadInfo.creationTime,
+          messageID: null,
+          addedUserIDs: [],
+        };
+        void processAndSendDMOperation({
+          type: dmOperationSpecificationTypes.OUTBOUND,
+          op: operation,
+          recipients: {
+            type: 'some_devices',
+            deviceIDs: [...recipients],
+          },
+          sendOnly: true,
+        });
+      }
+    })();
+  }, [
+    identityContext,
+    processAndSendDMOperation,
+    threadInfos,
+    userDeviceIDs,
+    viewerID,
+  ]);
+
+  return null;
+}
+
+export { InitialStateSharingHandler };
diff --git a/lib/shared/dm-ops/add-viewer-to-thread-members-spec.js b/lib/shared/dm-ops/add-viewer-to-thread-members-spec.js
index 251ba1591..b1d1461e4 100644
--- a/lib/shared/dm-ops/add-viewer-to-thread-members-spec.js
+++ b/lib/shared/dm-ops/add-viewer-to-thread-members-spec.js
@@ -1,144 +1,150 @@
 // @flow
 
 import uuid from 'uuid';
 
 import { createThickRawThreadInfo } from './create-thread-spec.js';
 import type {
   DMOperationSpec,
   ProcessDMOperationUtilities,
 } from './dm-op-spec.js';
 import type { DMAddViewerToThreadMembersOperation } from '../../types/dm-ops.js';
 import { messageTypes } from '../../types/message-types-enum.js';
 import { messageTruncationStatus } from '../../types/message-types.js';
 import type { AddMembersMessageData } from '../../types/messages/add-members.js';
 import { joinThreadSubscription } from '../../types/subscription-types.js';
 import { updateTypes } from '../../types/update-types-enum.js';
 import { rawMessageInfoFromMessageData } from '../message-utils.js';
 import { userIsMember } from '../thread-utils.js';
 
 function createAddViewerToThreadMembersMessageDataFromDMOp(
   dmOperation: DMAddViewerToThreadMembersOperation,
 ): AddMembersMessageData {
   const { editorID, time, addedUserIDs, existingThreadDetails } = dmOperation;
   return {
     type: messageTypes.ADD_MEMBERS,
     threadID: existingThreadDetails.threadID,
     creatorID: editorID,
     time,
     addedUserIDs: [...addedUserIDs],
   };
 }
 
 const addViewerToThreadMembersSpec: DMOperationSpec<DMAddViewerToThreadMembersOperation> =
   Object.freeze({
     notificationsCreationData: async (
       dmOperation: DMAddViewerToThreadMembersOperation,
     ) => {
       const messageData =
         createAddViewerToThreadMembersMessageDataFromDMOp(dmOperation);
       return { messageDatas: [messageData] };
     },
     processDMOperation: async (
       dmOperation: DMAddViewerToThreadMembersOperation,
       viewerID: string,
       utilities: ProcessDMOperationUtilities,
     ) => {
       const { time, messageID, addedUserIDs, existingThreadDetails } =
         dmOperation;
       const messageData =
         createAddViewerToThreadMembersMessageDataFromDMOp(dmOperation);
 
       const rawMessageInfos = messageID
         ? [rawMessageInfoFromMessageData(messageData, messageID)]
         : [];
 
       const threadID = existingThreadDetails.threadID;
       const currentThreadInfo = utilities.threadInfos[threadID];
       if (currentThreadInfo && !currentThreadInfo.thick) {
         return {
           rawMessageInfos: [],
           updateInfos: [],
         };
       }
 
       const memberTimestamps = {
         ...currentThreadInfo?.timestamps?.members,
       };
       const newMembers = [];
       for (const userID of addedUserIDs) {
         if (!memberTimestamps[userID]) {
           memberTimestamps[userID] = {
             isMember: time,
             subscription: existingThreadDetails.creationTime,
           };
         }
 
         if (memberTimestamps[userID].isMember > time) {
           continue;
         }
 
         memberTimestamps[userID] = {
           ...memberTimestamps[userID],
           isMember: time,
         };
 
         if (!userIsMember(currentThreadInfo, userID)) {
           newMembers.push(userID);
         }
       }
 
       const resultThreadInfo = createThickRawThreadInfo(
         {
           ...existingThreadDetails,
           allMemberIDsWithSubscriptions: [
             ...existingThreadDetails.allMemberIDsWithSubscriptions,
             ...newMembers.map(id => ({
               id,
               subscription: joinThreadSubscription,
             })),
           ],
           timestamps: {
             ...existingThreadDetails.timestamps,
             members: {
               ...existingThreadDetails.timestamps.members,
               ...memberTimestamps,
             },
           },
         },
         viewerID,
       );
       const updateInfos = [
         {
           type: updateTypes.JOIN_THREAD,
           id: uuid.v4(),
           time,
           threadInfo: resultThreadInfo,
           rawMessageInfos,
           truncationStatus: messageTruncationStatus.EXHAUSTIVE,
           rawEntryInfos: [],
         },
       ];
       return { rawMessageInfos, updateInfos };
     },
     canBeProcessed(
       dmOperation: DMAddViewerToThreadMembersOperation,
       viewerID: string,
     ) {
-      if (dmOperation.addedUserIDs.includes(viewerID)) {
+      // We expect the viewer to be in the added users when the DM op
+      // is processed. An exception is for ops generated
+      // by InitialStateSharingHandler, which won't contain a messageID
+      if (
+        dmOperation.addedUserIDs.includes(viewerID) ||
+        !dmOperation.messageID
+      ) {
         return { isProcessingPossible: true };
       }
       console.log('Invalid DM operation', dmOperation);
       return {
         isProcessingPossible: false,
         reason: {
           type: 'invalid',
         },
       };
     },
     supportsAutoRetry: true,
   });
 
 export {
   addViewerToThreadMembersSpec,
   createAddViewerToThreadMembersMessageDataFromDMOp,
 };
diff --git a/native/root.react.js b/native/root.react.js
index 425c1e5d7..d35e57669 100644
--- a/native/root.react.js
+++ b/native/root.react.js
@@ -1,430 +1,432 @@
 // @flow
 
 import { ActionSheetProvider } from '@expo/react-native-action-sheet';
 import { BottomSheetModalProvider } from '@gorhom/bottom-sheet';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import type {
   PossiblyStaleNavigationState,
   UnsafeContainerActionEvent,
   GenericNavigationAction,
 } from '@react-navigation/core';
 import { useReduxDevToolsExtension } from '@react-navigation/devtools';
 import { NavigationContainer } from '@react-navigation/native';
 import * as SplashScreen from 'expo-splash-screen';
 import invariant from 'invariant';
 import * as React from 'react';
 import { StyleSheet } from 'react-native';
 import { GestureHandlerRootView } from 'react-native-gesture-handler';
 import Orientation from 'react-native-orientation-locker';
 import {
   SafeAreaProvider,
   initialWindowMetrics,
 } from 'react-native-safe-area-context';
 import { Provider } from 'react-redux';
 import { PersistGate as ReduxPersistGate } from 'redux-persist/es/integration/react.js';
 
 import { ChatMentionContextProvider } from 'lib/components/chat-mention-provider.react.js';
 import { EditUserAvatarProvider } from 'lib/components/edit-user-avatar-provider.react.js';
 import { ENSCacheProvider } from 'lib/components/ens-cache-provider.react.js';
 import { FarcasterDataHandler } from 'lib/components/farcaster-data-handler.react.js';
 import IntegrityHandler from 'lib/components/integrity-handler.react.js';
 import { MediaCacheProvider } from 'lib/components/media-cache-provider.react.js';
 import { NeynarClientProvider } from 'lib/components/neynar-client-provider.react.js';
 import PlatformDetailsSynchronizer from 'lib/components/platform-details-synchronizer.react.js';
 import PrekeysHandler from 'lib/components/prekeys-handler.react.js';
 import { QRAuthProvider } from 'lib/components/qr-auth-provider.react.js';
 import { StaffContextProvider } from 'lib/components/staff-provider.react.js';
 import { UserIdentityCacheProvider } from 'lib/components/user-identity-cache.react.js';
 import { DBOpsHandler } from 'lib/handlers/db-ops-handler.react.js';
+import { InitialStateSharingHandler } from 'lib/handlers/initial-state-sharing-handler.react.js';
 import { TunnelbrokerDeviceTokenHandler } from 'lib/handlers/tunnelbroker-device-token-handler.react.js';
 import { UserInfosHandler } from 'lib/handlers/user-infos-handler.react.js';
 import { IdentitySearchProvider } from 'lib/identity-search/identity-search-context.js';
 import { CallKeyserverEndpointProvider } from 'lib/keyserver-conn/call-keyserver-endpoint-provider.react.js';
 import KeyserverConnectionsHandler from 'lib/keyserver-conn/keyserver-connections-handler.js';
 import { TunnelbrokerProvider } from 'lib/tunnelbroker/tunnelbroker-context.js';
 import { actionLogger } from 'lib/utils/action-logger.js';
 
 import { RegistrationContextProvider } from './account/registration/registration-context-provider.react.js';
 import NativeEditThreadAvatarProvider from './avatars/native-edit-thread-avatar-provider.react.js';
 import BackupHandler from './backup/backup-handler.js';
 import { BottomSheetProvider } from './bottom-sheet/bottom-sheet-provider.react.js';
 import ChatContextProvider from './chat/chat-context-provider.react.js';
 import MessageEditingContextProvider from './chat/message-editing-context-provider.react.js';
 import AccessTokenHandler from './components/access-token-handler.react.js';
 import { AutoJoinCommunityHandler } from './components/auto-join-community-handler.react.js';
 import BackgroundIdentityLoginHandler from './components/background-identity-login-handler.react.js';
 import ConnectFarcasterAlertHandler from './components/connect-farcaster-alert-handler.react.js';
 import DMActivityHandler from './components/dm-activity-handler.react.js';
 import { FeatureFlagsProvider } from './components/feature-flags-provider.react.js';
 import { NUXTipsContextProvider } from './components/nux-tips-context.react.js';
 import PersistedStateGate from './components/persisted-state-gate.js';
 import ReportHandler from './components/report-handler.react.js';
 import VersionSupportedChecker from './components/version-supported.react.js';
 import ConnectedStatusBar from './connected-status-bar.react.js';
 import { SQLiteDataHandler } from './data/sqlite-data-handler.js';
 import ErrorBoundary from './error-boundary.react.js';
 import IdentityServiceContextProvider from './identity-service/identity-service-context-provider.react.js';
 import InputStateContainer from './input/input-state-container.react.js';
 import LifecycleHandler from './lifecycle/lifecycle-handler.react.js';
 import MarkdownContextProvider from './markdown/markdown-context-provider.react.js';
 import { filesystemMediaCache } from './media/media-cache.js';
 import { DeepLinksContextProvider } from './navigation/deep-links-context-provider.react.js';
 import { defaultNavigationState } from './navigation/default-state.js';
 import { setGlobalNavContext } from './navigation/icky-global.js';
 import KeyserverReachabilityHandler from './navigation/keyserver-reachability-handler.js';
 import {
   NavContext,
   type NavContextType,
 } from './navigation/navigation-context.js';
 import NavigationHandler from './navigation/navigation-handler.react.js';
 import { validNavState } from './navigation/navigation-utils.js';
 import OrientationHandler from './navigation/orientation-handler.react.js';
 import { navStateAsyncStorageKey } from './navigation/persistance.js';
 import RootNavigator from './navigation/root-navigator.react.js';
 import {
   composeTunnelbrokerQRAuthMessage,
   handleSecondaryDeviceLogInError,
   parseTunnelbrokerQRAuthMessage,
   performBackupRestore,
   generateQRAuthAESKey,
 } from './qr-code/qr-code-utils.js';
 import ConnectivityUpdater from './redux/connectivity-updater.react.js';
 import { DimensionsUpdater } from './redux/dimensions-updater.react.js';
 import { getPersistor } from './redux/persist.js';
 import { store } from './redux/redux-setup.js';
 import { useSelector } from './redux/redux-utils.js';
 import { RootContext } from './root-context.js';
 import { MessageSearchProvider } from './search/search-provider.react.js';
 import Socket from './socket.react.js';
 import { useLoadCommFonts } from './themes/fonts.js';
 import { DarkTheme, LightTheme } from './themes/navigation.js';
 import ThemeHandler from './themes/theme-handler.react.js';
 import { provider } from './utils/ethers-utils.js';
 import { neynarKey } from './utils/neynar-utils.js';
 
 // Add custom items to expo-dev-menu
 import './dev-menu.js';
 import './types/message-types-validator.js';
 
 const navInitAction = Object.freeze({ type: 'NAV/@@INIT' });
 const navUnknownAction = Object.freeze({ type: 'NAV/@@UNKNOWN' });
 
 SplashScreen.preventAutoHideAsync().catch(console.log);
 
 function Root() {
   const navStateRef = React.useRef<?PossiblyStaleNavigationState>();
   const navDispatchRef =
     React.useRef<?(
       action:
         | GenericNavigationAction
         | (PossiblyStaleNavigationState => GenericNavigationAction),
     ) => void>();
   const navStateInitializedRef = React.useRef(false);
 
   // We call this here to start the loading process
   // We gate the UI on the fonts loading in AppNavigator
   useLoadCommFonts();
 
   const [navContext, setNavContext] = React.useState<?NavContextType>(null);
   const updateNavContext = React.useCallback(() => {
     if (
       !navStateRef.current ||
       !navDispatchRef.current ||
       !navStateInitializedRef.current
     ) {
       return;
     }
     const updatedNavContext = {
       state: navStateRef.current,
       dispatch: navDispatchRef.current,
     };
     setNavContext(updatedNavContext);
     setGlobalNavContext(updatedNavContext);
   }, []);
 
   const [initialState, setInitialState] = React.useState(
     __DEV__ ? undefined : defaultNavigationState,
   );
 
   React.useEffect(() => {
     Orientation.lockToPortrait();
     void (async () => {
       let loadedState = initialState;
       if (__DEV__) {
         try {
           const navStateString = await AsyncStorage.getItem(
             navStateAsyncStorageKey,
           );
           if (navStateString) {
             const savedState = JSON.parse(navStateString);
             if (validNavState(savedState)) {
               loadedState = savedState;
             }
           }
         } catch {}
       }
       if (!loadedState) {
         loadedState = defaultNavigationState;
       }
       if (loadedState !== initialState) {
         setInitialState(loadedState);
       }
       navStateRef.current = loadedState;
       updateNavContext();
       actionLogger.addOtherAction('navState', navInitAction, null, loadedState);
     })();
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [updateNavContext]);
 
   const setNavStateInitialized = React.useCallback(() => {
     navStateInitializedRef.current = true;
     updateNavContext();
   }, [updateNavContext]);
 
   const [rootContext, setRootContext] = React.useState(() => ({
     setNavStateInitialized,
   }));
 
   const detectUnsupervisedBackgroundRef = React.useCallback(
     (detectUnsupervisedBackground: ?(alreadyClosed: boolean) => boolean) => {
       setRootContext(prevRootContext => ({
         ...prevRootContext,
         detectUnsupervisedBackground,
       }));
     },
     [],
   );
 
   const frozen = useSelector(state => state.frozen);
   const queuedActionsRef = React.useRef<Array<GenericNavigationAction>>([]);
   const onNavigationStateChange = React.useCallback(
     (state: ?PossiblyStaleNavigationState) => {
       invariant(state, 'nav state should be non-null');
       const prevState = navStateRef.current;
       navStateRef.current = state;
       updateNavContext();
 
       const queuedActions = queuedActionsRef.current;
       queuedActionsRef.current = [];
       if (queuedActions.length === 0) {
         queuedActions.push(navUnknownAction);
       }
       for (const action of queuedActions) {
         actionLogger.addOtherAction('navState', action, prevState, state);
       }
 
       if (!__DEV__ || frozen) {
         return;
       }
 
       void (async () => {
         try {
           await AsyncStorage.setItem(
             navStateAsyncStorageKey,
             JSON.stringify(state),
           );
         } catch (e) {
           console.log('AsyncStorage threw while trying to persist navState', e);
         }
       })();
     },
     [updateNavContext, frozen],
   );
 
   const navContainerRef =
     React.useRef<?React.ElementRef<typeof NavigationContainer>>();
   const containerRef = React.useCallback(
     (navContainer: ?React.ElementRef<typeof NavigationContainer>) => {
       navContainerRef.current = navContainer;
       if (navContainer && !navDispatchRef.current) {
         navDispatchRef.current = navContainer.dispatch;
         updateNavContext();
       }
     },
     [updateNavContext],
   );
   useReduxDevToolsExtension(navContainerRef);
 
   const navContainer = navContainerRef.current;
   React.useEffect(() => {
     if (!navContainer) {
       return undefined;
     }
     return navContainer.addListener(
       '__unsafe_action__',
       (event: { +data: UnsafeContainerActionEvent, ... }) => {
         const { action, noop } = event.data;
         const navState = navStateRef.current;
         if (noop) {
           actionLogger.addOtherAction('navState', action, navState, navState);
           return;
         }
         queuedActionsRef.current.push({
           ...action,
           type: `NAV/${action.type}`,
         });
       },
     );
   }, [navContainer]);
 
   const activeTheme = useSelector(state => state.globalThemeInfo.activeTheme);
   const theme = (() => {
     if (activeTheme === 'light') {
       return LightTheme;
     } else if (activeTheme === 'dark') {
       return DarkTheme;
     }
     return undefined;
   })();
 
   const gated: React.Node = (
     <>
       <LifecycleHandler />
       <KeyserverReachabilityHandler />
       <DimensionsUpdater />
       <ConnectivityUpdater />
       <ThemeHandler />
       <OrientationHandler />
       <BackupHandler />
       <IntegrityHandler />
       <AccessTokenHandler />
       <DBOpsHandler />
       <UserInfosHandler />
       <TunnelbrokerDeviceTokenHandler />
     </>
   );
   let navigation;
   if (initialState) {
     navigation = (
       <NavigationContainer
         initialState={initialState}
         onStateChange={onNavigationStateChange}
         theme={theme}
         ref={containerRef}
       >
         <BottomSheetModalProvider>
           <ChatContextProvider>
             <DeepLinksContextProvider>
               <ChatMentionContextProvider>
                 <NUXTipsContextProvider>
                   <RootNavigator />
                 </NUXTipsContextProvider>
               </ChatMentionContextProvider>
             </DeepLinksContextProvider>
           </ChatContextProvider>
           <NavigationHandler />
           <PersistedStateGate>
             <FarcasterDataHandler>
               <ConnectFarcasterAlertHandler />
             </FarcasterDataHandler>
           </PersistedStateGate>
         </BottomSheetModalProvider>
       </NavigationContainer>
     );
   }
   return (
     <GestureHandlerRootView style={styles.app}>
       <StaffContextProvider>
         <IdentityServiceContextProvider>
           <UserIdentityCacheProvider>
             <TunnelbrokerProvider>
               <IdentitySearchProvider>
                 <QRAuthProvider
                   parseTunnelbrokerQRAuthMessage={
                     parseTunnelbrokerQRAuthMessage
                   }
                   composeTunnelbrokerQRAuthMessage={
                     composeTunnelbrokerQRAuthMessage
                   }
                   generateAESKey={generateQRAuthAESKey}
                   performBackupRestore={performBackupRestore}
                   onLogInError={handleSecondaryDeviceLogInError}
                 >
                   <FeatureFlagsProvider>
                     <NavContext.Provider value={navContext}>
                       <RootContext.Provider value={rootContext}>
                         <InputStateContainer>
                           <MessageEditingContextProvider>
                             <SafeAreaProvider
                               initialMetrics={initialWindowMetrics}
                             >
                               <ActionSheetProvider>
                                 <ENSCacheProvider provider={provider}>
                                   <NeynarClientProvider apiKey={neynarKey}>
                                     <MediaCacheProvider
                                       persistence={filesystemMediaCache}
                                     >
                                       <EditUserAvatarProvider>
                                         <NativeEditThreadAvatarProvider>
                                           <MarkdownContextProvider>
                                             <MessageSearchProvider>
                                               <BottomSheetProvider>
                                                 <RegistrationContextProvider>
                                                   <SQLiteDataHandler />
                                                   <ConnectedStatusBar />
                                                   <ReduxPersistGate
                                                     persistor={getPersistor()}
                                                   >
                                                     {gated}
                                                   </ReduxPersistGate>
                                                   <PersistedStateGate>
                                                     <KeyserverConnectionsHandler
                                                       socketComponent={Socket}
                                                       detectUnsupervisedBackgroundRef={
                                                         detectUnsupervisedBackgroundRef
                                                       }
                                                     />
                                                     <DMActivityHandler />
                                                     <VersionSupportedChecker />
                                                     <PlatformDetailsSynchronizer />
                                                     <BackgroundIdentityLoginHandler />
                                                     <PrekeysHandler />
                                                     <ReportHandler />
                                                     <AutoJoinCommunityHandler />
+                                                    <InitialStateSharingHandler />
                                                   </PersistedStateGate>
                                                   {navigation}
                                                 </RegistrationContextProvider>
                                               </BottomSheetProvider>
                                             </MessageSearchProvider>
                                           </MarkdownContextProvider>
                                         </NativeEditThreadAvatarProvider>
                                       </EditUserAvatarProvider>
                                     </MediaCacheProvider>
                                   </NeynarClientProvider>
                                 </ENSCacheProvider>
                               </ActionSheetProvider>
                             </SafeAreaProvider>
                           </MessageEditingContextProvider>
                         </InputStateContainer>
                       </RootContext.Provider>
                     </NavContext.Provider>
                   </FeatureFlagsProvider>
                 </QRAuthProvider>
               </IdentitySearchProvider>
             </TunnelbrokerProvider>
           </UserIdentityCacheProvider>
         </IdentityServiceContextProvider>
       </StaffContextProvider>
     </GestureHandlerRootView>
   );
 }
 
 const styles = StyleSheet.create({
   app: {
     flex: 1,
   },
 });
 
 function AppRoot(): React.Node {
   return (
     <Provider store={store}>
       <CallKeyserverEndpointProvider>
         <ErrorBoundary>
           <Root />
         </ErrorBoundary>
       </CallKeyserverEndpointProvider>
     </Provider>
   );
 }
 
 export default AppRoot;