diff --git a/External/Xal/External/libHttpClient b/External/Xal/External/libHttpClient
index 0a3381db..90896ee6 160000
--- a/External/Xal/External/libHttpClient
+++ b/External/Xal/External/libHttpClient
@@ -1 +1 @@
-Subproject commit 0a3381dbd6aa23e7d9c823b8d1bb04c67e5d5eb6
+Subproject commit 90896ee64322e4a74989699103439a55705de656
diff --git a/Source/Services/Achievements/Manager/achievements_manager_api.cpp b/Source/Services/Achievements/Manager/achievements_manager_api.cpp
index a0fba776..02915537 100644
--- a/Source/Services/Achievements/Manager/achievements_manager_api.cpp
+++ b/Source/Services/Achievements/Manager/achievements_manager_api.cpp
@@ -131,6 +131,7 @@ STDAPI XblAchievementsManagerDoWork(
     _Outptr_result_maybenull_ const XblAchievementsManagerEvent** achievementsEvents,
     _Out_ size_t* achievementsEventsCount
 ) XBL_NOEXCEPT
+try
 {
     INIT_OUT_PTR_PARAM(achievementsEvents);
 
@@ -149,12 +150,14 @@ STDAPI XblAchievementsManagerDoWork(
         }
     );
 }
+CATCH_RETURN()
 
 STDAPI XblAchievementsManagerGetAchievement(
     _In_ uint64_t xboxUserId,
     _In_ const char* achievementId,
     _Outptr_result_maybenull_ XblAchievementsManagerResultHandle* achievementResult
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(achievementId == nullptr || achievementResult == nullptr);
     RETURN_HR_INVALIDARGUMENT_IF_EMPTY_STRING(achievementId);
@@ -176,6 +179,7 @@ STDAPI XblAchievementsManagerGetAchievement(
         }
     );
 }
+CATCH_RETURN()
 
 STDAPI XblAchievementsManagerGetAchievements(
     _In_ uint64_t xboxUserId,
@@ -183,6 +187,7 @@ STDAPI XblAchievementsManagerGetAchievements(
     _In_ XblAchievementsManagerSortOrder sortOrder,
     _Outptr_result_maybenull_ XblAchievementsManagerResultHandle* achievementsResult
 ) XBL_NOEXCEPT
+try
 {
     INIT_OUT_PTR_PARAM(achievementsResult);
     
@@ -229,6 +234,7 @@ STDAPI XblAchievementsManagerGetAchievements(
         }
     );
 }
+CATCH_RETURN()
 
 STDAPI XblAchievementsManagerGetAchievementsByState(
     _In_ uint64_t xboxUserId,
@@ -237,6 +243,7 @@ STDAPI XblAchievementsManagerGetAchievementsByState(
     _In_ XblAchievementProgressState achievementState,
     _Outptr_result_maybenull_ XblAchievementsManagerResultHandle* achievementsResult
 ) XBL_NOEXCEPT
+try
 {
     INIT_OUT_PTR_PARAM(achievementsResult);
 
@@ -291,12 +298,14 @@ STDAPI XblAchievementsManagerGetAchievementsByState(
         }
     );
 }
+CATCH_RETURN()
 
 STDAPI XblAchievementsManagerUpdateAchievement(
     _In_ uint64_t xboxUserId,
     _In_ const char* achievementId,
     _In_ uint8_t currentProgress
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](AchievementsManager& achievementsManager)
         {
@@ -314,4 +323,5 @@ STDAPI XblAchievementsManagerUpdateAchievement(
             return S_OK;
         }
     );
-}
\ No newline at end of file
+}
+CATCH_RETURN()
diff --git a/Source/Services/Achievements/achievements_api.cpp b/Source/Services/Achievements/achievements_api.cpp
index 090ec3ed..2731a59e 100644
--- a/Source/Services/Achievements/achievements_api.cpp
+++ b/Source/Services/Achievements/achievements_api.cpp
@@ -186,9 +186,11 @@ STDAPI XblAchievementsResultGetNextResult(
     _In_ XAsyncBlock* async,
     _Out_ XblAchievementsResultHandle* result
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResult(async, nullptr, sizeof(XblAchievementsResultHandle), result, nullptr);
 }
+CATCH_RETURN()
 
 STDAPI XblAchievementsUpdateAchievementAsyncInternal(
     _In_ XblContextHandle xboxLiveContextHandle,
diff --git a/Source/Services/Common/xbox_live_context_api.cpp b/Source/Services/Common/xbox_live_context_api.cpp
index 944a473f..aa5aec6a 100644
--- a/Source/Services/Common/xbox_live_context_api.cpp
+++ b/Source/Services/Common/xbox_live_context_api.cpp
@@ -88,6 +88,7 @@ CATCH_RETURN()
 void XblSetApiType(
     _In_ XblApiType apiType
 ) XBL_NOEXCEPT
+try
 {
     auto state = GlobalState::Get();
     if (state)
@@ -95,3 +96,4 @@ void XblSetApiType(
         state->ApiType = apiType;
     }
 }
+CATCH_RETURN_WITH(;)
\ No newline at end of file
diff --git a/Source/Services/Common/xbox_live_context_settings.cpp b/Source/Services/Common/xbox_live_context_settings.cpp
index e8c695b7..24da48d2 100644
--- a/Source/Services/Common/xbox_live_context_settings.cpp
+++ b/Source/Services/Common/xbox_live_context_settings.cpp
@@ -95,21 +95,25 @@ STDAPI XblContextSettingsGetLongHttpTimeout(
     _In_ XblContextHandle context,
     _Out_ uint32_t* timeoutInSeconds
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(context == nullptr || timeoutInSeconds == nullptr);
     *timeoutInSeconds = context->Settings()->LongHttpTimeout();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblContextSettingsSetLongHttpTimeout(
     _In_ XblContextHandle context,
     _In_ uint32_t timeoutInSeconds
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(context == nullptr);
     context->Settings()->SetLongHttpTimeout(timeoutInSeconds);
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblContextSettingsGetHttpRetryDelay(
     _In_ XblContextHandle context,
@@ -188,39 +192,47 @@ STDAPI XblContextSettingsGetUseCoreDispatcherForEventRouting(
     _In_ XblContextHandle context,
     _Out_ bool* useDispatcher
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(context == nullptr || useDispatcher == nullptr);
     *useDispatcher = context->Settings()->UseCoreDispatcherForEventRouting();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblContextSettingsSetUseCoreDispatcherForEventRouting(
     _In_ XblContextHandle context,
     _In_ bool useDispatcher
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(context == nullptr);
     context->Settings()->SetUseCoreDispatcherForEventRouting(useDispatcher);
     return S_OK;
 }
+CATCH_RETURN()
 #endif
 
 STDAPI XblContextSettingsGetUseCrossPlatformQosServers(
     _In_ XblContextHandle context,
     _Out_ bool* value
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(context == nullptr || value == nullptr);
     *value = context->Settings()->UseCrossplatformQosServers();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblContextSettingsSetUseCrossPlatformQosServers(
     _In_ XblContextHandle context,
     _In_ bool value
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(context);
     context->Settings()->SetUseCrossplatformQosServers(value);
     return S_OK;
-}
\ No newline at end of file
+}
+CATCH_RETURN()
diff --git a/Source/Services/Common/xbox_live_global_api.cpp b/Source/Services/Common/xbox_live_global_api.cpp
index 8a7f27c5..c3084b60 100644
--- a/Source/Services/Common/xbox_live_global_api.cpp
+++ b/Source/Services/Common/xbox_live_global_api.cpp
@@ -15,6 +15,7 @@ STDAPI XblMemSetFunctions(
     _In_opt_ XblMemAllocFunction memAllocFunc,
     _In_opt_ XblMemFreeFunction memFreeFunc
 ) XBL_NOEXCEPT
+try
 {
     if (GlobalState::Get())
     {
@@ -47,11 +48,13 @@ STDAPI XblMemSetFunctions(
 
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMemGetFunctions(
     _Out_ XblMemAllocFunction* memAllocFunc,
     _Out_ XblMemFreeFunction* memFreeFunc
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(memAllocFunc == nullptr || memFreeFunc == nullptr);
 
@@ -59,6 +62,7 @@ STDAPI XblMemGetFunctions(
     *memFreeFunc = g_pMemFreeHook;
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblInitialize(
     _In_ const XblInitArgs* args
@@ -112,16 +116,17 @@ CATCH_RETURN();
 
 STDAPI_(XblErrorCondition)
 XblGetErrorCondition(
-    _In_ HRESULT hr
+    _In_ HRESULT inHr
     ) XBL_NOEXCEPT
+try
 {
-    if (SUCCEEDED(hr))
+    if (SUCCEEDED(inHr))
     {
         return XblErrorCondition::NoError;
     }
-    else if (HRESULT_FACILITY(hr) == FACILITY_HTTP)
+    else if (HRESULT_FACILITY(inHr) == FACILITY_HTTP)
     {
-        switch (hr)
+        switch (inHr)
         {
         case HTTP_E_STATUS_NOT_MODIFIED:
             return XblErrorCondition::Http304NotModified;
@@ -139,18 +144,18 @@ XblGetErrorCondition(
             return XblErrorCondition::HttpGeneric;
         }
     }
-    else if (HRESULT_FACILITY(hr) == FACILITY_INTERNET)
+    else if (HRESULT_FACILITY(inHr) == FACILITY_INTERNET)
     {
         return XblErrorCondition::Network;
     }
-    else if ((hr >= (unsigned)xbl_error_code::AM_E_XASD_UNEXPECTED && hr <= (unsigned)xbl_error_code::AM_E_XTITLE_TIMEOUT) ||
-             (hr >= (unsigned)xbl_error_code::XO_E_DEVMODE_NOT_AUTHORIZED && hr <= (unsigned)xbl_error_code::XO_E_CONTENT_NOT_AUTHORIZED))
+    else if ((inHr >= (unsigned)xbl_error_code::AM_E_XASD_UNEXPECTED && inHr <= (unsigned)xbl_error_code::AM_E_XTITLE_TIMEOUT) ||
+             (inHr >= (unsigned)xbl_error_code::XO_E_DEVMODE_NOT_AUTHORIZED && inHr <= (unsigned)xbl_error_code::XO_E_CONTENT_NOT_AUTHORIZED))
     {
         return XblErrorCondition::Auth;
     }
     else
     {
-        switch (hr)
+        switch (inHr)
         {
         case ONL_E_ACTION_REQUIRED:
         case E_XBL_AUTH_UNKNOWN_ERROR:
@@ -166,6 +171,7 @@ XblGetErrorCondition(
         }
     }
 }
+CATCH_RETURN_WITH(XblErrorCondition::GenericError)
 
 STDAPI_(void) XblDisableAssertsForXboxLiveThrottlingInDevSandboxes(
     _In_ XblConfigSetting setting
@@ -195,6 +201,7 @@ STDAPI_(XblFunctionContext) XblAddServiceCallRoutedHandler(
     _In_ XblCallRoutedHandler handler,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     auto state{ GlobalState::Get() };
     if (state && handler)
@@ -206,10 +213,12 @@ STDAPI_(XblFunctionContext) XblAddServiceCallRoutedHandler(
         return XblFunctionContext{ 0 };
     }
 }
+CATCH_RETURN()
 
 STDAPI_(void) XblRemoveServiceCallRoutedHandler(
     _In_ XblFunctionContext token
 ) XBL_NOEXCEPT
+try
 {
     auto state{ GlobalState::Get() };
     if (state)
@@ -217,4 +226,5 @@ STDAPI_(void) XblRemoveServiceCallRoutedHandler(
         state->RemoveServiceCallRoutedHandler(token);
     }
 }
+CATCH_RETURN_WITH(;)
 
diff --git a/Source/Services/Events/events_service_api.cpp b/Source/Services/Events/events_service_api.cpp
index 0919dd80..2adf4c03 100644
--- a/Source/Services/Events/events_service_api.cpp
+++ b/Source/Services/Events/events_service_api.cpp
@@ -13,27 +13,33 @@ STDAPI XblEventsWriteInGameEvent(
     _In_opt_z_ const char* dimensions,
     _In_opt_z_ const char* measurements
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xboxLiveContext == nullptr || eventName == nullptr);
     VERIFY_XBL_INITIALIZED();
 
     return xboxLiveContext->EventsService()->WriteInGameEvent(eventName, dimensions, measurements);
 }
+CATCH_RETURN()
 
 #if XSAPI_INTERNAL_EVENTS_SERVICE
 
 STDAPI XblEventsSetStorageAllotment(
     uint64_t storageAllotmentInBytes
 ) XBL_NOEXCEPT
+try
 {
     return events::EventQueue::SetStorageAllotment(storageAllotmentInBytes);
 }
+CATCH_RETURN()
 
 STDAPI XblEventsSetMaxFileSize(
     uint64_t maxFileSizeInByes
 ) XBL_NOEXCEPT
+try
 {
     return events::EventQueue::SetMaxFileSize(maxFileSizeInByes);
 }
+CATCH_RETURN()
 
 #endif // !XSAPI_ETW_EVENTS_SERVICE
\ No newline at end of file
diff --git a/Source/Services/Leaderboard/leaderboard_service.cpp b/Source/Services/Leaderboard/leaderboard_service.cpp
index 4f7f84f3..a816b6fb 100644
--- a/Source/Services/Leaderboard/leaderboard_service.cpp
+++ b/Source/Services/Leaderboard/leaderboard_service.cpp
@@ -430,6 +430,7 @@ STDAPI XblLeaderboardGetLeaderboardAsync(
     _In_ XblLeaderboardQuery leaderboardQuery,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     VERIFY_XBL_INITIALIZED();
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xboxLiveContext);
@@ -533,14 +534,17 @@ STDAPI XblLeaderboardGetLeaderboardAsync(
         );
     }
 }
+CATCH_RETURN()
 
 STDAPI XblLeaderboardGetLeaderboardResultSize(
     _In_ XAsyncBlock* async,
     _Out_ size_t* resultSizeInBytes
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResultSize(async, resultSizeInBytes);
 }
+CATCH_RETURN()
 
 STDAPI XblLeaderboardGetLeaderboardResult(
     _In_ XAsyncBlock* async,
@@ -549,6 +553,7 @@ STDAPI XblLeaderboardGetLeaderboardResult(
     _Outptr_ XblLeaderboardResult** ptrToBuffer,
     _Out_opt_ size_t* bufferUsed
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(ptrToBuffer);
     auto hr = XAsyncGetResult(async, nullptr, bufferSize, buffer, bufferUsed);
@@ -558,6 +563,7 @@ STDAPI XblLeaderboardGetLeaderboardResult(
     }
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblLeaderboardResultGetNextAsync(
     _In_ XblContextHandle xboxLiveContext,
@@ -565,6 +571,7 @@ STDAPI XblLeaderboardResultGetNextAsync(
     _In_ uint32_t maxItems,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xboxLiveContext);
     RETURN_HR_IF(leaderboardResult->nextQuery.continuationToken == nullptr, E_BOUNDS);
@@ -576,14 +583,17 @@ STDAPI XblLeaderboardResultGetNextAsync(
         async
     );
 }
+CATCH_RETURN()
 
 STDAPI XblLeaderboardResultGetNextResultSize(
     _In_ XAsyncBlock* async,
     _Out_ size_t* resultSizeInBytes
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResultSize(async, resultSizeInBytes);
 }
+CATCH_RETURN()
 
 STDAPI XblLeaderboardResultGetNextResult(
     _In_ XAsyncBlock* async,
@@ -592,6 +602,7 @@ STDAPI XblLeaderboardResultGetNextResult(
     _Outptr_ XblLeaderboardResult** ptrToBuffer,
     _Out_opt_ size_t* bufferUsed
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(ptrToBuffer);
     VERIFY_XBL_INITIALIZED();
@@ -603,3 +614,4 @@ STDAPI XblLeaderboardResultGetNextResult(
     }
     return hr;
 }
+CATCH_RETURN()
diff --git a/Source/Services/Matchmaking/matchmaking_service.cpp b/Source/Services/Matchmaking/matchmaking_service.cpp
index 5b7284ab..5a09dd83 100644
--- a/Source/Services/Matchmaking/matchmaking_service.cpp
+++ b/Source/Services/Matchmaking/matchmaking_service.cpp
@@ -581,6 +581,7 @@ STDAPI XblMatchmakingCreateMatchTicketAsync(
     _In_ const char* ticketAttributesJson,
     _In_ XAsyncBlock* asyncBlock
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xboxLiveContext);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(matchmakingServiceConfigurationId);
@@ -598,6 +599,7 @@ STDAPI XblMatchmakingCreateMatchTicketAsync(
         JsonDocument().Parse(ticketAttributesJson),
         asyncBlock);
 }
+CATCH_RETURN()
 
 /// <summary>
 /// Get the result for an XblMatchmakingCreateMatchTicketAsync call.
@@ -611,10 +613,12 @@ STDAPI XblMatchmakingCreateMatchTicketResult(
     _In_ XAsyncBlock* asyncBlock,
     _Out_ XblCreateMatchTicketResponse* resultPtr
 ) XBL_NOEXCEPT 
+try
 {
     auto hr = XAsyncGetResult(asyncBlock, nullptr, sizeof(XblCreateMatchTicketResponse), resultPtr, nullptr);
     return hr;
 }
+CATCH_RETURN()
 
 /// <summary>
 /// Deletes a the match ticket on the server.
@@ -633,6 +637,7 @@ STDAPI XblMatchmakingDeleteMatchTicketAsync(
     _In_ const char* ticketId,
     _In_ XAsyncBlock* asyncBlock
 ) XBL_NOEXCEPT 
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xboxLiveContext);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(serviceConfiguration);
@@ -647,6 +652,7 @@ STDAPI XblMatchmakingDeleteMatchTicketAsync(
         ticketId,
         asyncBlock);
 }
+CATCH_RETURN()
 
 /// <summary>
 /// Retrieves the properties of a match ticket from the server.
@@ -667,6 +673,7 @@ STDAPI XblMatchmakingGetMatchTicketDetailsAsync(
     _In_ const char* ticketId,
     _In_ XAsyncBlock* asyncBlock
 ) XBL_NOEXCEPT 
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xboxLiveContext);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(serviceConfiguration);
@@ -682,6 +689,7 @@ STDAPI XblMatchmakingGetMatchTicketDetailsAsync(
         asyncBlock);
 
 }
+CATCH_RETURN()
 
 /// <summary>
 /// Get the result size for an XblMatchmakingGetMatchTicketDetailsAsync call.
@@ -692,9 +700,11 @@ STDAPI XblMatchmakingGetMatchTicketDetailsResultSize(
     _In_ XAsyncBlock* asyncBlock,
     _Out_ size_t* resultSizeInBytes
 ) XBL_NOEXCEPT 
+try
 {
     return XAsyncGetResultSize(asyncBlock, resultSizeInBytes);
 }
+CATCH_RETURN()
 
 /// <summary>
 /// Get the result for an XblMatchmakingGetMatchTicketDetailsAsync call.
@@ -711,6 +721,7 @@ STDAPI XblMatchmakingGetMatchTicketDetailsResult(
     _Outptr_ XblMatchTicketDetailsResponse** ptrToBuffer,
     _Out_opt_ size_t* bufferUsed
 ) XBL_NOEXCEPT 
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(ptrToBuffer);
     auto hr = XAsyncGetResult(asyncBlock, nullptr, bufferSize, buffer, bufferUsed);
@@ -720,6 +731,7 @@ STDAPI XblMatchmakingGetMatchTicketDetailsResult(
     }
     return hr;
 }
+CATCH_RETURN()
 
 /// <summary>
 /// Gets statistics about a hopper such as how many players are in it.
@@ -737,6 +749,7 @@ STDAPI XblMatchmakingGetHopperStatisticsAsync(
     _In_ const char* hopperName,
     _In_ XAsyncBlock* asyncBlock
 ) XBL_NOEXCEPT 
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xboxLiveContext);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(serviceConfiguration);
@@ -750,6 +763,7 @@ STDAPI XblMatchmakingGetHopperStatisticsAsync(
         asyncBlock
     );
 }
+CATCH_RETURN()
 
 /// <summary>
 /// Get the result size for an XblMatchmakingGetHopperStatisticsAsync call.
@@ -760,9 +774,11 @@ STDAPI XblMatchmakingGetHopperStatisticsResultSize(
     _In_ XAsyncBlock* asyncBlock,
     _Out_ size_t* resultSizeInBytes
 ) XBL_NOEXCEPT 
+try
 {
     return XAsyncGetResultSize(asyncBlock, resultSizeInBytes);
 }
+CATCH_RETURN()
 
 /// <summary>
 /// Get the result for an XblMatchmakingGetHopperStatisticsAsync call.
@@ -779,6 +795,7 @@ STDAPI XblMatchmakingGetHopperStatisticsResult(
     _Outptr_ XblHopperStatisticsResponse** ptrToBuffer,
     _Out_opt_ size_t* bufferUsed
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(ptrToBuffer);
     auto hr = XAsyncGetResult(asyncBlock, nullptr, bufferSize, buffer, bufferUsed);
@@ -788,3 +805,4 @@ STDAPI XblMatchmakingGetHopperStatisticsResult(
     }
     return hr;
 }
+CATCH_RETURN()
diff --git a/Source/Services/Multiplayer/Manager/multiplayer_event_args.cpp b/Source/Services/Multiplayer/Manager/multiplayer_event_args.cpp
index 20d51d72..68bc7ae0 100644
--- a/Source/Services/Multiplayer/Manager/multiplayer_event_args.cpp
+++ b/Source/Services/Multiplayer/Manager/multiplayer_event_args.cpp
@@ -12,6 +12,7 @@ STDAPI XblMultiplayerEventArgsXuid(
     _In_ XblMultiplayerEventArgsHandle argsHandle,
     _Out_ uint64_t* xuid
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(argsHandle == nullptr || xuid == nullptr);
     VERIFY_XBL_INITIALIZED();
@@ -38,11 +39,13 @@ STDAPI XblMultiplayerEventArgsXuid(
     }
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerEventArgsMembersCount(
     _In_ XblMultiplayerEventArgsHandle argsHandle,
     _Out_ size_t* memberCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(argsHandle == nullptr || memberCount == nullptr);
 
@@ -63,12 +66,14 @@ STDAPI XblMultiplayerEventArgsMembersCount(
     }
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerEventArgsMembers(
     _In_ XblMultiplayerEventArgsHandle argsHandle,
     _In_ size_t membersCount,
     _Out_writes_(membersCount) XblMultiplayerManagerMember* members
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(argsHandle == nullptr || members == nullptr);
 
@@ -96,11 +101,13 @@ STDAPI XblMultiplayerEventArgsMembers(
     }
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerEventArgsMember(
     _In_ XblMultiplayerEventArgsHandle argsHandle,
     _Out_ XblMultiplayerManagerMember* member
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(argsHandle == nullptr || member == nullptr);
 
@@ -135,11 +142,13 @@ STDAPI XblMultiplayerEventArgsMember(
     }
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerEventArgsPropertiesJson(
     _In_ XblMultiplayerEventArgsHandle argsHandle,
     _Out_ const char** properties
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(argsHandle == nullptr || properties == nullptr);
 
@@ -160,12 +169,14 @@ STDAPI XblMultiplayerEventArgsPropertiesJson(
     }
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerEventArgsFindMatchCompleted(
     _In_ XblMultiplayerEventArgsHandle argsHandle,
     _Out_opt_ XblMultiplayerMatchStatus* matchStatus,
     _Out_opt_ XblMultiplayerMeasurementFailure* initializationFailureCause
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(argsHandle);
     auto args = dynamic_cast<FindMatchCompletedEventArgs*>(argsHandle);
@@ -181,34 +192,40 @@ STDAPI XblMultiplayerEventArgsFindMatchCompleted(
     }
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerEventArgsTournamentRegistrationStateChanged(
     _In_ XblMultiplayerEventArgsHandle argsHandle,
     _Out_opt_ XblTournamentRegistrationState* registrationState,
     _Out_opt_ XblTournamentRegistrationReason* registrationReason
 ) XBL_NOEXCEPT
+try
 {
     UNREFERENCED_PARAMETER(argsHandle);
     UNREFERENCED_PARAMETER(registrationState);
     UNREFERENCED_PARAMETER(registrationReason);
     return E_NOTIMPL;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerEventArgsTournamentGameSessionReady(
     _In_ XblMultiplayerEventArgsHandle argsHandle,
     _Out_ time_t* startTime
 ) XBL_NOEXCEPT
+try
 {
     UNREFERENCED_PARAMETER(argsHandle);
     UNREFERENCED_PARAMETER(startTime);
 
     return E_NOTIMPL;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerEventArgsPerformQoSMeasurements(
     _In_ XblMultiplayerEventArgsHandle argsHandle,
     _Out_ XblMultiplayerPerformQoSMeasurementsArgs* performQoSMeasurementsArgs
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(argsHandle == nullptr || performQoSMeasurementsArgs == nullptr);
     auto args = dynamic_cast<PerformQosMeasurementsEventArgs*>(argsHandle);
@@ -218,4 +235,5 @@ STDAPI XblMultiplayerEventArgsPerformQoSMeasurements(
     performQoSMeasurementsArgs->remoteClients = args->remoteClients.data();
 
     return S_OK;
-}
\ No newline at end of file
+}
+CATCH_RETURN()
diff --git a/Source/Services/Multiplayer/Manager/multiplayer_manager_api.cpp b/Source/Services/Multiplayer/Manager/multiplayer_manager_api.cpp
index ea6e0a93..5f7cdb44 100644
--- a/Source/Services/Multiplayer/Manager/multiplayer_manager_api.cpp
+++ b/Source/Services/Multiplayer/Manager/multiplayer_manager_api.cpp
@@ -38,6 +38,7 @@ STDAPI XblMultiplayerManagerInitialize(
     _In_z_ const char* lobbySessionTemplateName,
     _In_opt_ XTaskQueueHandle asyncQueue
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -47,11 +48,13 @@ STDAPI XblMultiplayerManagerInitialize(
             return S_OK;
         }, false); // doesn't require init
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerDoWork(
     _Deref_out_opt_ const XblMultiplayerEvent** multiplayerEvents,
     _Out_ size_t* multiplayerEventsCount
 ) XBL_NOEXCEPT
+try
 {
     INIT_OUT_PTR_PARAM(multiplayerEvents);
 
@@ -73,11 +76,13 @@ STDAPI XblMultiplayerManagerDoWork(
             return S_OK;
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerJoinLobby(
     _In_z_ const char* handleId,
     _In_ XblUserHandle user
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -85,10 +90,12 @@ STDAPI XblMultiplayerManagerJoinLobby(
             return mpm.JoinLobby(handleId, user);
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerJoinGameFromLobby(
     _In_z_ const char* sessionTemplateName
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -96,6 +103,7 @@ STDAPI XblMultiplayerManagerJoinGameFromLobby(
             return mpm.JoinGameFromLobby(sessionTemplateName);
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerJoinGame(
     _In_z_ const char* sessionName,
@@ -103,6 +111,7 @@ STDAPI XblMultiplayerManagerJoinGame(
     _In_opt_ const uint64_t* xuids,
     _In_ size_t xuidsCount
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -115,20 +124,24 @@ STDAPI XblMultiplayerManagerJoinGame(
             );
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerLeaveGame() XBL_NOEXCEPT
+try
 {
     return ApiImpl([](MultiplayerManager& mpm)
         {
             return mpm.LeaveGame();
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerFindMatch(
     _In_z_ const char* hopperName,
     _In_opt_z_ const char* attributesJson,
     _In_ uint32_t timeoutInSeconds
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -152,8 +165,10 @@ STDAPI XblMultiplayerManagerFindMatch(
             );
         });
 }
+CATCH_RETURN()
 
 STDAPI_(void) XblMultiplayerManagerCancelMatch() XBL_NOEXCEPT
+try
 {
     ApiImpl([](MultiplayerManager& mpm)
         {
@@ -161,34 +176,42 @@ STDAPI_(void) XblMultiplayerManagerCancelMatch() XBL_NOEXCEPT
             return S_OK;
         });
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI_(XblMultiplayerMatchStatus) XblMultiplayerManagerMatchStatus() XBL_NOEXCEPT
+try
 {
     return ApiImpl(XblMultiplayerMatchStatus::None, [](MultiplayerManager& mpm)
         {
             return mpm.MatchStatus();
         });
 }
+CATCH_RETURN_WITH(XblMultiplayerMatchStatus::None)
 
 STDAPI_(uint32_t) XblMultiplayerManagerEstimatedMatchWaitTime() XBL_NOEXCEPT
+try
 {
     return ApiImpl(0, [](MultiplayerManager& mpm)
         {
             return static_cast<uint32_t>(mpm.EstimatedMatchWaitTime().count());
         });
 }
+CATCH_RETURN_WITH(0)
 
 STDAPI_(bool) XblMultiplayerManagerAutoFillMembersDuringMatchmaking() XBL_NOEXCEPT
+try
 {
     return ApiImpl(false, [](MultiplayerManager& mpm)
         {
             return mpm.AutoFillMembersDuringMatchmaking();
         });
 }
+CATCH_RETURN_WITH(false)
 
 STDAPI_(void) XblMultiplayerManagerSetAutoFillMembersDuringMatchmaking(
     _In_ bool autoFillMembers
 ) XBL_NOEXCEPT
+try
 {
     ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -196,10 +219,12 @@ STDAPI_(void) XblMultiplayerManagerSetAutoFillMembersDuringMatchmaking(
             return S_OK;
         });
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI XblMultiplayerManagerSetQosMeasurements(
     _In_z_ const char* measurementsJson
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -217,29 +242,35 @@ STDAPI XblMultiplayerManagerSetQosMeasurements(
             return S_OK;
         });
 }
+CATCH_RETURN()
 
 STDAPI_(XblMultiplayerJoinability) XblMultiplayerManagerJoinability() XBL_NOEXCEPT
+try
 {
     return ApiImpl(XblMultiplayerJoinability::None, [](MultiplayerManager& mpm)
         {
             return mpm.Joinability();
         });
 }
+CATCH_RETURN_WITH(XblMultiplayerJoinability::None)
 
 STDAPI XblMultiplayerManagerSetJoinability(
     _In_ XblMultiplayerJoinability joinability,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
             return mpm.SetJoinability(joinability, reinterpret_cast<context_t>(context));
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerLobbySessionCorrelationId(
     _Out_ XblGuid* correlationId
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -248,10 +279,12 @@ STDAPI XblMultiplayerManagerLobbySessionCorrelationId(
             return S_OK;
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerLobbySessionSessionReference(
     _Out_ XblMultiplayerSessionReference* sessionReference
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -260,19 +293,23 @@ STDAPI XblMultiplayerManagerLobbySessionSessionReference(
             return S_OK;
         });
 }
+CATCH_RETURN()
 
 STDAPI_(size_t) XblMultiplayerManagerLobbySessionLocalMembersCount() XBL_NOEXCEPT
+try
 {
     return ApiImpl<size_t>(0, [](MultiplayerManager& mpm)
         {
             return mpm.LobbySession()->LocalMembers().size();
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerLobbySessionLocalMembers(
     _In_ size_t localMembersCount,
     _Out_writes_(localMembersCount) XblMultiplayerManagerMember* localMembers
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -289,19 +326,23 @@ STDAPI XblMultiplayerManagerLobbySessionLocalMembers(
             return S_OK;
         });
 }
+CATCH_RETURN()
 
 STDAPI_(size_t) XblMultiplayerManagerLobbySessionMembersCount() XBL_NOEXCEPT
+try
 {
     return ApiImpl<size_t>(0, [](MultiplayerManager& mpm)
         {
             return mpm.LobbySession()->Members().size();
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerLobbySessionMembers(
     _In_ size_t membersCount,
     _Out_writes_(membersCount) XblMultiplayerManagerMember* members
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -314,10 +355,12 @@ STDAPI XblMultiplayerManagerLobbySessionMembers(
             return S_OK;
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerLobbySessionHost(
     _Out_ XblMultiplayerManagerMember* hostMember
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -332,8 +375,10 @@ STDAPI XblMultiplayerManagerLobbySessionHost(
             }
         });
 }
+CATCH_RETURN()
 
 STDAPI_(const char*) XblMultiplayerManagerLobbySessionPropertiesJson() XBL_NOEXCEPT
+try
 {
     return ApiImpl<const char*>(nullptr, [](MultiplayerManager& mpm)-> const char*
         {
@@ -346,42 +391,51 @@ STDAPI_(const char*) XblMultiplayerManagerLobbySessionPropertiesJson() XBL_NOEXC
         });
     
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI_(const XblMultiplayerSessionConstants*) XblMultiplayerManagerLobbySessionConstants() XBL_NOEXCEPT
+try
 {
     return ApiImpl<const XblMultiplayerSessionConstants*>(nullptr, [](MultiplayerManager& mpm)
         {
             return &mpm.LobbySession()->SessionConstants();
         });
 }
+CATCH_RETURN_WITH(nullptr)
 
 XBL_WARNING_PUSH
 XBL_WARNING_DISABLE_DEPRECATED
 STDAPI_(const XblTournamentTeamResult*) XblMultiplayerManagerLobbySessionLastTournamentTeamResult() XBL_NOEXCEPT
+try
 {
     return nullptr;
 }
+CATCH_RETURN_WITH(nullptr)
 XBL_WARNING_POP
 
 STDAPI XblMultiplayerManagerLobbySessionAddLocalUser(
     _In_ XblUserHandle user
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
             return mpm.LobbySession()->AddLocalUser(user);
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerLobbySessionRemoveLocalUser(
     _In_ XblUserHandle user
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
             return mpm.LobbySession()->RemoveLocalUser(user);
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerLobbySessionSetLocalMemberProperties(
     _In_ XblUserHandle user,
@@ -389,6 +443,7 @@ STDAPI XblMultiplayerManagerLobbySessionSetLocalMemberProperties(
     _In_z_ const char* valueJson,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -410,12 +465,14 @@ STDAPI XblMultiplayerManagerLobbySessionSetLocalMemberProperties(
             );
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerLobbySessionDeleteLocalMemberProperties(
     _In_ XblUserHandle user,
     _In_z_ const char* name,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -427,12 +484,14 @@ STDAPI XblMultiplayerManagerLobbySessionDeleteLocalMemberProperties(
             );
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerLobbySessionSetLocalMemberConnectionAddress(
     _In_ XblUserHandle user,
     _In_z_ const char* connectionAddress,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -444,22 +503,26 @@ STDAPI XblMultiplayerManagerLobbySessionSetLocalMemberConnectionAddress(
             );
         });
 }
+CATCH_RETURN()
 
 STDAPI_(bool) XblMultiplayerManagerLobbySessionIsHost(
     _In_ uint64_t xuid
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl(false, [&](MultiplayerManager& mpm)
         {
             return mpm.LobbySession()->IsHost(xuid);
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerLobbySessionSetProperties(
     _In_z_ const char* name,
     _In_z_ const char* valueJson,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -480,12 +543,14 @@ STDAPI XblMultiplayerManagerLobbySessionSetProperties(
             );
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerLobbySessionSetSynchronizedProperties(
     _In_z_ const char* name,
     _In_z_ const char* valueJson,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -506,11 +571,13 @@ STDAPI XblMultiplayerManagerLobbySessionSetSynchronizedProperties(
             );
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerLobbySessionSetSynchronizedHost(
     _In_ const char* deviceToken,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -521,6 +588,7 @@ STDAPI XblMultiplayerManagerLobbySessionSetSynchronizedHost(
             );
         });
 }
+CATCH_RETURN()
 
 #if HC_PLATFORM_IS_MICROSOFT
 STDAPI XblMultiplayerManagerLobbySessionInviteFriends(
@@ -528,6 +596,7 @@ STDAPI XblMultiplayerManagerLobbySessionInviteFriends(
     _In_opt_z_ const char* contextStringId,
     _In_opt_z_ const char* customActivationContext
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -538,6 +607,7 @@ STDAPI XblMultiplayerManagerLobbySessionInviteFriends(
             );
         });
 }
+CATCH_RETURN()
 #endif
 
 STDAPI XblMultiplayerManagerLobbySessionInviteUsers(
@@ -547,6 +617,7 @@ STDAPI XblMultiplayerManagerLobbySessionInviteUsers(
     _In_opt_z_ const char* contextStringId,
     _In_opt_z_ const char* customActivationContext
 ) XBL_NOEXCEPT
+try
 {
     return ApiImpl([&](MultiplayerManager& mpm)
         {
@@ -558,6 +629,7 @@ STDAPI XblMultiplayerManagerLobbySessionInviteUsers(
             );
         });
 }
+CATCH_RETURN()
 
 NAMESPACE_MICROSOFT_XBOX_SERVICES_MULTIPLAYER_MANAGER_CPP_BEGIN
 
@@ -609,41 +681,50 @@ typedef std::shared_ptr<MultiplayerGameSession> GameSessionPtr;
 NAMESPACE_MICROSOFT_XBOX_SERVICES_MULTIPLAYER_MANAGER_CPP_END
 
 STDAPI_(bool) XblMultiplayerManagerGameSessionActive() XBL_NOEXCEPT
+try
 {
     return ApiImpl(false, [](MultiplayerManager& mpm)
         {
             return mpm.GameSession() != nullptr;
         });
 }
+CATCH_RETURN()
 
 STDAPI_(const char*) XblMultiplayerManagerGameSessionCorrelationId() XBL_NOEXCEPT
+try
 {
     return GameSessionApiImpl<const char*>(nullptr, [](GameSessionPtr gameSession)
         {
             return gameSession->CorrelationId().data();
         });
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI_(const XblMultiplayerSessionReference*) XblMultiplayerManagerGameSessionSessionReference() XBL_NOEXCEPT
+try
 {
     return GameSessionApiImpl<const XblMultiplayerSessionReference *>(nullptr, [](GameSessionPtr gameSession)
         {
             return &gameSession->SessionReference();
         });
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI_(size_t) XblMultiplayerManagerGameSessionMembersCount() XBL_NOEXCEPT
+try
 {
     return GameSessionApiImpl<size_t>(0, [](GameSessionPtr gameSession)
         {
             return gameSession->Members().size();
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerGameSessionMembers(
     _In_ size_t membersCount,
     _Out_writes_(membersCount) XblMultiplayerManagerMember* members
 ) XBL_NOEXCEPT
+try
 {
     return GameSessionApiImpl([&](GameSessionPtr gameSession)
         {
@@ -660,10 +741,12 @@ STDAPI XblMultiplayerManagerGameSessionMembers(
             return S_OK;
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerGameSessionHost(
     _Out_ XblMultiplayerManagerMember* hostMember
 ) XBL_NOEXCEPT
+try
 {
     return GameSessionApiImpl([&](GameSessionPtr gameSession)
         {
@@ -678,38 +761,46 @@ STDAPI XblMultiplayerManagerGameSessionHost(
             }
         });
 }
+CATCH_RETURN()
 
 STDAPI_(const char*) XblMultiplayerManagerGameSessionPropertiesJson() XBL_NOEXCEPT
+try
 {
     return GameSessionApiImpl<const char*>(nullptr, [](GameSessionPtr gameSession)
         {
             return gameSession->Properties().data();
         });
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI_(const XblMultiplayerSessionConstants*) XblMultiplayerManagerGameSessionConstants() XBL_NOEXCEPT
+try
 {
     return GameSessionApiImpl<const XblMultiplayerSessionConstants*>(nullptr, [](GameSessionPtr gameSession)
         {
             return &gameSession->SessionConstants();
         });
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI_(bool) XblMultiplayerManagerGameSessionIsHost(
     _In_ uint64_t xuid
 ) XBL_NOEXCEPT
+try
 {
     return GameSessionApiImpl(false, [&](GameSessionPtr gameSession)
         {
             return gameSession->IsHost(xuid);
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerGameSessionSetProperties(
     _In_z_ const char* name,
     _In_z_ const char* valueJson,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     return GameSessionApiImpl([&](GameSessionPtr gameSession)
         {
@@ -730,12 +821,14 @@ STDAPI XblMultiplayerManagerGameSessionSetProperties(
             );
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerGameSessionSetSynchronizedProperties(
     _In_z_ const char* name,
     _In_z_ const char* valueJson,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     return GameSessionApiImpl([&](GameSessionPtr gameSession)
         {
@@ -756,11 +849,13 @@ STDAPI XblMultiplayerManagerGameSessionSetSynchronizedProperties(
             );
         });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerManagerGameSessionSetSynchronizedHost(
     _In_ const char* deviceToken,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     return GameSessionApiImpl([&](GameSessionPtr gameSession)
         {
@@ -769,4 +864,5 @@ STDAPI XblMultiplayerManagerGameSessionSetSynchronizedHost(
             return gameSession->SetSynchronizedHost(deviceToken, reinterpret_cast<context_t>(context));
         });
 }
+CATCH_RETURN()
 
diff --git a/Source/Services/Multiplayer/Manager/multiplayer_member.cpp b/Source/Services/Multiplayer/Manager/multiplayer_member.cpp
index c300d33c..2c2f30f1 100644
--- a/Source/Services/Multiplayer/Manager/multiplayer_member.cpp
+++ b/Source/Services/Multiplayer/Manager/multiplayer_member.cpp
@@ -11,6 +11,7 @@ STDAPI_(bool) XblMultiplayerManagerMemberAreMembersOnSameDevice(
     _In_ const XblMultiplayerManagerMember* first,
     _In_ const XblMultiplayerManagerMember* second
 ) XBL_NOEXCEPT
+try
 {
     if (first != nullptr && second != nullptr)
     {
@@ -18,6 +19,7 @@ STDAPI_(bool) XblMultiplayerManagerMemberAreMembersOnSameDevice(
     }
     return false;
 }
+CATCH_RETURN()
 
 NAMESPACE_MICROSOFT_XBOX_SERVICES_MULTIPLAYER_MANAGER_CPP_BEGIN
 
diff --git a/Source/Services/Multiplayer/multiplayer_api.cpp b/Source/Services/Multiplayer/multiplayer_api.cpp
index 37c90b28..ac52898f 100644
--- a/Source/Services/Multiplayer/multiplayer_api.cpp
+++ b/Source/Services/Multiplayer/multiplayer_api.cpp
@@ -13,6 +13,7 @@ STDAPI XblMultiplayerSearchHandleDuplicateHandle(
     _In_ XblMultiplayerSearchHandle handle,
     _Out_ XblMultiplayerSearchHandle* duplicatedHandle
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(handle == nullptr || duplicatedHandle == nullptr);
 
@@ -21,42 +22,50 @@ STDAPI XblMultiplayerSearchHandleDuplicateHandle(
 
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI_(void) XblMultiplayerSearchHandleCloseHandle(
     _In_ XblMultiplayerSearchHandle handle
 ) XBL_NOEXCEPT
+try
 {
     if (handle)
     {
         handle->DecRef();
     }
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI XblMultiplayerSearchHandleGetSessionReference(
     _In_ XblMultiplayerSearchHandle handle,
     _Out_ XblMultiplayerSessionReference* sessionRef
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(handle == nullptr || sessionRef == nullptr);
     *sessionRef = handle->SessionReference();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSearchHandleGetId(
     _In_ XblMultiplayerSearchHandle handle,
     _Out_ const char** id
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(handle == nullptr || id == nullptr);
     *id = handle->HandleId().data();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSearchHandleGetSessionOwnerXuids(
     _In_ XblMultiplayerSearchHandle handle,
     _Out_ const uint64_t** xuids,
     _Out_ size_t* xuidsCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(handle == nullptr || xuids == nullptr || xuidsCount == nullptr);
 
@@ -64,12 +73,14 @@ STDAPI XblMultiplayerSearchHandleGetSessionOwnerXuids(
     *xuidsCount = handle->SessionOwnerXuids().size();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSearchHandleGetTags(
     _In_ XblMultiplayerSearchHandle handle,
     _Out_ const XblMultiplayerSessionTag** tags,
     _Out_ size_t* tagsCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(handle == nullptr || tags == nullptr || tagsCount == nullptr);
 
@@ -77,12 +88,14 @@ STDAPI XblMultiplayerSearchHandleGetTags(
     *tagsCount = handle->Tags().size();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSearchHandleGetStringAttributes(
     _In_ XblMultiplayerSearchHandle handle,
     _Out_ const XblMultiplayerSessionStringAttribute** attributes,
     _Out_ size_t* attributesCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(handle == nullptr || attributes == nullptr || attributesCount == nullptr);
 
@@ -90,12 +103,14 @@ STDAPI XblMultiplayerSearchHandleGetStringAttributes(
     *attributesCount = handle->StringAttributes().size();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSearchHandleGetNumberAttributes(
     _In_ XblMultiplayerSearchHandle handle,
     _Out_ const XblMultiplayerSessionNumberAttribute** attributes,
     _Out_ size_t* attributesCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(handle == nullptr || attributes == nullptr || attributesCount == nullptr);
 
@@ -103,42 +118,50 @@ STDAPI XblMultiplayerSearchHandleGetNumberAttributes(
     *attributesCount = handle->NumberAttributes().size();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSearchHandleGetVisibility(
     _In_ XblMultiplayerSearchHandle handle,
     _Out_ XblMultiplayerSessionVisibility* visibility
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(handle == nullptr || visibility == nullptr);
     *visibility = handle->Visibility();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSearchHandleGetJoinRestriction(
     _In_ XblMultiplayerSearchHandle handle,
     _Out_ XblMultiplayerSessionRestriction* joinRestriction
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(handle == nullptr || joinRestriction == nullptr);
     *joinRestriction = handle->JoinRestriction();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSearchHandleGetSessionClosed(
     _In_ XblMultiplayerSearchHandle handle,
     _Out_ bool* closed
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(handle == nullptr || closed == nullptr);
     *closed = handle->Closed();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSearchHandleGetMemberCounts(
     _In_ XblMultiplayerSearchHandle handle,
     _Out_opt_ size_t* maxMembers,
     _Out_opt_ size_t* currentMembers
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(handle == nullptr);
 
@@ -152,21 +175,25 @@ STDAPI XblMultiplayerSearchHandleGetMemberCounts(
     }
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSearchHandleGetCreationTime(
     _In_ XblMultiplayerSearchHandle handle,
     _Out_ time_t* creationTime
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(handle == nullptr || creationTime == nullptr);
     *creationTime = utils::time_t_from_datetime(handle->HandleCreationTime());
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSearchHandleGetCustomSessionPropertiesJson(
     _In_ XblMultiplayerSearchHandle handle,
     _Out_ const char** customPropertiesJson
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(handle == nullptr || customPropertiesJson == nullptr);
     auto& customPropertiesString{ handle->CustomSessionPropertiesJson() };
@@ -180,6 +207,7 @@ STDAPI XblMultiplayerSearchHandleGetCustomSessionPropertiesJson(
     }
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerCreateSearchHandleAsync(
     _In_ XblContextHandle xblContext,
@@ -192,6 +220,7 @@ STDAPI XblMultiplayerCreateSearchHandleAsync(
     _In_ size_t stringAttributesCount,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContext == nullptr || sessionRef == nullptr || async == nullptr);
     RETURN_HR_INVALIDARGUMENT_IF(tagsCount > 0 && tags == nullptr);
@@ -282,11 +311,13 @@ STDAPI XblMultiplayerCreateSearchHandleAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerCreateSearchHandleResult(
     _In_ XAsyncBlock* async,
     _Out_opt_ XblMultiplayerSearchHandle* handle
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(async);
 
@@ -305,12 +336,14 @@ STDAPI XblMultiplayerCreateSearchHandleResult(
     }
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerDeleteSearchHandleAsync(
     _In_ XblContextHandle xblContext,
     _In_ const char* handleId,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContext == nullptr || handleId == nullptr || async == nullptr);
 
@@ -332,6 +365,7 @@ STDAPI XblMultiplayerDeleteSearchHandleAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetSearchHandlesAsync(
     _In_ XblContextHandle xblContext,
@@ -343,6 +377,7 @@ STDAPI XblMultiplayerGetSearchHandlesAsync(
     _In_opt_z_ const char* socialGroup,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContext == nullptr || scid == nullptr || sessionTemplateName == nullptr || async == nullptr);
 
@@ -408,11 +443,13 @@ STDAPI XblMultiplayerGetSearchHandlesAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetSearchHandlesResultCount(
     _In_ XAsyncBlock* async,
     _Out_ size_t* searchHandleCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(async == nullptr || searchHandleCount == nullptr);
 
@@ -425,17 +462,20 @@ STDAPI XblMultiplayerGetSearchHandlesResultCount(
     }
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetSearchHandlesResult(
     _In_ XAsyncBlock* async,
     _Out_writes_(searchHandlesCount) XblMultiplayerSearchHandle* searchHandles,
     _In_ size_t searchHandlesCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_IF(searchHandlesCount == 0, S_OK);
     RETURN_HR_INVALIDARGUMENT_IF(async == nullptr || searchHandles == nullptr);
     return XAsyncGetResult(async, nullptr, searchHandlesCount * sizeof(XblMultiplayerSearchHandle), searchHandles, nullptr);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSetTransferHandleAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -443,6 +483,7 @@ STDAPI XblMultiplayerSetTransferHandleAsync(
     _In_ XblMultiplayerSessionReference originSessionReference,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(async);
 
@@ -490,11 +531,14 @@ STDAPI XblMultiplayerSetTransferHandleAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSetTransferHandleResult(
     _In_ XAsyncBlock* async,
     _Out_ XblMultiplayerSessionHandleId* handleId
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResult(async, nullptr, sizeof(XblMultiplayerSessionHandleId), handleId, nullptr);
-}
\ No newline at end of file
+}
+CATCH_RETURN()
diff --git a/Source/Services/Multiplayer/multiplayer_service.cpp b/Source/Services/Multiplayer/multiplayer_service.cpp
index 6791bd1d..2ad72387 100644
--- a/Source/Services/Multiplayer/multiplayer_service.cpp
+++ b/Source/Services/Multiplayer/multiplayer_service.cpp
@@ -1372,6 +1372,7 @@ STDAPI MultiplayerWriteSessionHelper(
     _In_opt_ const char* handleIdArg,
     _Inout_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || multiplayerSession == nullptr || async == nullptr);
 
@@ -1450,6 +1451,7 @@ STDAPI MultiplayerWriteSessionHelper(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerWriteSessionAsync(
     _In_ XblContextHandle xblContext,
@@ -1457,6 +1459,7 @@ STDAPI XblMultiplayerWriteSessionAsync(
     _In_ XblMultiplayerSessionWriteMode writeMode,
     _Inout_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(multiplayerSession);
 
@@ -1468,11 +1471,13 @@ STDAPI XblMultiplayerWriteSessionAsync(
 
     return MultiplayerWriteSessionHelper(xblContext, multiplayerSession, writeMode, nullptr, async);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerWriteSessionResult(
     _Inout_ XAsyncBlock* async,
     _Out_ XblMultiplayerSessionHandle* handle
 ) XBL_NOEXCEPT
+try
 {
     XblMultiplayerSessionHandle handleCopy = nullptr;
     auto hr = XAsyncGetResult(async, nullptr, sizeof(XblMultiplayerSessionHandle), &handleCopy, nullptr);
@@ -1486,6 +1491,7 @@ STDAPI XblMultiplayerWriteSessionResult(
     }
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerWriteSessionByHandleAsync(
     _In_ XblContextHandle xblContext,
@@ -1494,19 +1500,23 @@ STDAPI XblMultiplayerWriteSessionByHandleAsync(
     _In_ const char* handleId,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(handleId);
 
     return MultiplayerWriteSessionHelper(xblContext, multiplayerSession, writeMode, handleId, async);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerWriteSessionByHandleResult(
     _Inout_ XAsyncBlock* async,
     _Out_ XblMultiplayerSessionHandle* handle
 ) XBL_NOEXCEPT
+try
 {
     return XblMultiplayerWriteSessionResult(async, handle);
 }
+CATCH_RETURN()
 
 STDAPI MultiplayerGetSessionHelper(
     _In_ XblContextHandle xblContextHandle,
@@ -1514,6 +1524,7 @@ STDAPI MultiplayerGetSessionHelper(
     _In_opt_ const char* handleIdArg,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || async == nullptr);
 
@@ -1574,48 +1585,58 @@ STDAPI MultiplayerGetSessionHelper(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetSessionAsync(
     _In_ XblContextHandle xblContext,
     _In_ const XblMultiplayerSessionReference* sessionReference,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(sessionReference);
     return MultiplayerGetSessionHelper(xblContext, sessionReference, nullptr, async);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetSessionResult(
     _In_ XAsyncBlock* async,
     _Out_ XblMultiplayerSessionHandle* handle
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResult(async, nullptr, sizeof(XblMultiplayerSessionHandle), handle, nullptr);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetSessionByHandleAsync(
     _In_ XblContextHandle xblContext,
     _In_ const char* handleId,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(handleId);
     return MultiplayerGetSessionHelper(xblContext, nullptr, handleId, async);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetSessionByHandleResult(
     _In_ XAsyncBlock* async,
     _Out_ XblMultiplayerSessionHandle* handle
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResult(async, nullptr, sizeof(XblMultiplayerSessionHandle), handle, nullptr);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerQuerySessionsAsync(
     _In_ XblContextHandle xblContextHandle,
     _In_ const XblMultiplayerSessionQuery* sessionQuery,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || sessionQuery == nullptr || async == nullptr);
     RETURN_HR_INVALIDARGUMENT_IF_EMPTY_STRING(sessionQuery->Scid);
@@ -1665,11 +1686,13 @@ STDAPI XblMultiplayerQuerySessionsAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerQuerySessionsResultCount(
     _In_ XAsyncBlock* async,
     _Out_ size_t* sessionCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(async == nullptr || sessionCount == nullptr);
 
@@ -1678,22 +1701,26 @@ STDAPI XblMultiplayerQuerySessionsResultCount(
     *sessionCount = sizeInBytes / sizeof(XblMultiplayerSessionQueryResult);
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerQuerySessionsResult(
     _In_ XAsyncBlock* async,
     _In_ size_t sessionCount,
     _Out_writes_(sessionCount) XblMultiplayerSessionQueryResult* sessions
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_IF(sessionCount == 0, S_OK);
     return XAsyncGetResult(async, nullptr, sessionCount * sizeof(XblMultiplayerSessionQueryResult), sessions, nullptr);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSetActivityAsync(
     _In_ XblContextHandle xblContextHandle,
     _In_ const XblMultiplayerSessionReference* sessionReferenceArg,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || sessionReferenceArg == nullptr || async == nullptr);
 
@@ -1718,12 +1745,14 @@ STDAPI XblMultiplayerSetActivityAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerClearActivityAsync(
     _In_ XblContextHandle xblContextHandle,
     _In_z_ const char* scidArg,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || scidArg == nullptr || async == nullptr);
 
@@ -1748,6 +1777,7 @@ STDAPI XblMultiplayerClearActivityAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSendInvitesAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -1759,6 +1789,7 @@ STDAPI XblMultiplayerSendInvitesAsync(
     _In_opt_z_ const char* customActivationContext,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || sessionReference == nullptr || xuids == nullptr || xuidsCount == 0 || async == nullptr);
 
@@ -1817,16 +1848,19 @@ STDAPI XblMultiplayerSendInvitesAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSendInvitesResult(
     _In_ XAsyncBlock* async,
     _In_ size_t handlesCount,
     _Out_writes_(handlesCount) XblMultiplayerInviteHandle* handles
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_IF(handlesCount == 0, S_OK);
     return XAsyncGetResult(async, nullptr, sizeof(XblMultiplayerInviteHandle) * handlesCount, handles, nullptr);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetActivitiesForSocialGroupAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -1835,6 +1869,7 @@ STDAPI XblMultiplayerGetActivitiesForSocialGroupAsync(
     _In_ const char* socialGroupArg,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || scidArg == nullptr || socialGroupOwnerXuid == 0 || socialGroupArg == nullptr || async == nullptr);
 
@@ -1887,6 +1922,7 @@ STDAPI XblMultiplayerGetActivitiesForSocialGroupAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetActivitiesWithPropertiesForSocialGroupAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -1895,6 +1931,7 @@ STDAPI XblMultiplayerGetActivitiesWithPropertiesForSocialGroupAsync(
     _In_ const char* socialGroupArg,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || scidArg == nullptr || socialGroupOwnerXuid == 0 || socialGroupArg == nullptr || async == nullptr);
 
@@ -1966,11 +2003,13 @@ STDAPI XblMultiplayerGetActivitiesWithPropertiesForSocialGroupAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetActivitiesForSocialGroupResultCount(
     _In_ XAsyncBlock* async,
     _Out_ size_t* activityCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(activityCount);
 
@@ -1979,26 +2018,31 @@ STDAPI XblMultiplayerGetActivitiesForSocialGroupResultCount(
     *activityCount = sizeInBytes / sizeof(XblMultiplayerActivityDetails);
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetActivitiesForSocialGroupResult(
     _In_ XAsyncBlock* async,
     _In_ size_t activityCount,
     _Out_writes_(activityCount) XblMultiplayerActivityDetails* activities
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_IF(activityCount == 0, S_OK);
     return XAsyncGetResult(async, nullptr, activityCount * sizeof(XblMultiplayerActivityDetails), activities, nullptr);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetActivitiesWithPropertiesForSocialGroupResultSize(
     _In_ XAsyncBlock* async,
     _Out_ size_t* resultSizeInBytes
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(resultSizeInBytes);
 
     return XAsyncGetResultSize(async, resultSizeInBytes);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetActivitiesWithPropertiesForSocialGroupResult(
     _In_ XAsyncBlock* async,
@@ -2008,6 +2052,7 @@ STDAPI XblMultiplayerGetActivitiesWithPropertiesForSocialGroupResult(
     _Out_ size_t* ptrToBufferCount,
     _Out_opt_ size_t* bufferUsed
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(buffer == nullptr || ptrToBuffer == nullptr || ptrToBufferCount == nullptr);
 
@@ -2037,6 +2082,7 @@ STDAPI XblMultiplayerGetActivitiesWithPropertiesForSocialGroupResult(
 
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetActivitiesForUsersAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -2045,6 +2091,7 @@ STDAPI XblMultiplayerGetActivitiesForUsersAsync(
     _In_ size_t xuidsCount,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || scidArg == nullptr || xuidsArg == nullptr || xuidsCount == 0 || async == nullptr);
 
@@ -2095,6 +2142,7 @@ STDAPI XblMultiplayerGetActivitiesForUsersAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetActivitiesWithPropertiesForUsersAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -2103,6 +2151,7 @@ STDAPI XblMultiplayerGetActivitiesWithPropertiesForUsersAsync(
     _In_ size_t xuidsCount,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || scidArg == nullptr || xuidsArg == nullptr || xuidsCount == 0 || async == nullptr);
 
@@ -2172,31 +2221,38 @@ STDAPI XblMultiplayerGetActivitiesWithPropertiesForUsersAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetActivitiesForUsersResultCount(
     _In_ XAsyncBlock* async,
     _Out_ size_t* activityCount
 ) XBL_NOEXCEPT
+try
 {
     return XblMultiplayerGetActivitiesForSocialGroupResultCount(async, activityCount);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetActivitiesForUsersResult(
     _In_ XAsyncBlock* async,
     _In_ size_t activityCount,
     _Out_writes_(activityCount) XblMultiplayerActivityDetails* activities
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResult(async, nullptr, activityCount * sizeof(XblMultiplayerActivityDetails), activities, nullptr);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetActivitiesWithPropertiesForUsersResultSize(
     _In_ XAsyncBlock* async,
     _Out_ size_t* resultSizeInBytes
 ) XBL_NOEXCEPT
+try
 {
     return XblMultiplayerGetActivitiesWithPropertiesForSocialGroupResultSize(async, resultSizeInBytes);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerGetActivitiesWithPropertiesForUsersResult(
     _In_ XAsyncBlock* async,
@@ -2206,14 +2262,17 @@ STDAPI XblMultiplayerGetActivitiesWithPropertiesForUsersResult(
     _Out_ size_t* ptrToBufferCount,
     _Out_opt_ size_t* bufferUsed
 ) XBL_NOEXCEPT
+try
 {
     return XblMultiplayerGetActivitiesWithPropertiesForSocialGroupResult(async, bufferSize, buffer, ptrToBuffer, ptrToBufferCount, bufferUsed);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSetSubscriptionsEnabled(
     _In_ XblContextHandle xblContext,
     _In_ bool subscriptionsEnabled
 ) XBL_NOEXCEPT
+try
 {
     if (subscriptionsEnabled)
     {
@@ -2224,19 +2283,23 @@ STDAPI XblMultiplayerSetSubscriptionsEnabled(
         return xblContext->MultiplayerService()->DisableMultiplayerSubscriptions();
     }
 }
+CATCH_RETURN()
 
 STDAPI_(bool) XblMultiplayerSubscriptionsEnabled(
     _In_ XblContextHandle xblContext
 ) XBL_NOEXCEPT
+try
 {
     return xblContext->MultiplayerService()->SubscriptionsEnabled();
 }
+CATCH_RETURN()
 
 STDAPI_(XblFunctionContext) XblMultiplayerAddSessionChangedHandler(
     _In_ XblContextHandle xblContext,
     _In_ XblMultiplayerSessionChangedHandler* handler,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     return xblContext->MultiplayerService()->AddMultiplayerSessionChangedHandler(
         [
@@ -2255,20 +2318,25 @@ STDAPI_(XblFunctionContext) XblMultiplayerAddSessionChangedHandler(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI_(void) XblMultiplayerRemoveSessionChangedHandler(
     _In_ XblContextHandle xblContext,
     _In_ XblFunctionContext token
 ) XBL_NOEXCEPT
+try
 {
     xblContext->MultiplayerService()->RemoveMultiplayerSessionChangedHandler(token);
 }
+CATCH_RETURN_WITH(;)
+
 
 STDAPI_(XblFunctionContext) XblMultiplayerAddSubscriptionLostHandler(
     _In_ XblContextHandle xblContext,
     _In_ XblMultiplayerSessionSubscriptionLostHandler* handler,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     return xblContext->MultiplayerService()->AddMultiplayerSubscriptionLostHandler(
         [
@@ -2286,20 +2354,24 @@ STDAPI_(XblFunctionContext) XblMultiplayerAddSubscriptionLostHandler(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI_(void) XblMultiplayerRemoveSubscriptionLostHandler(
     _In_ XblContextHandle xblContext,
     _In_ XblFunctionContext token
 ) XBL_NOEXCEPT
+try
 {
     xblContext->MultiplayerService()->RemoveMultiplayerSubscriptionLostHandler(token);
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI_(XblFunctionContext) XblMultiplayerAddConnectionIdChangedHandler(
     _In_ XblContextHandle xblContext,
     _In_ XblMultiplayerConnectionIdChangedHandler* handler,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     return xblContext->MultiplayerService()->AddMultiplayerConnectionIdChangedHandler(
         [
@@ -2318,11 +2390,14 @@ STDAPI_(XblFunctionContext) XblMultiplayerAddConnectionIdChangedHandler(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI_(void) XblMultiplayerRemoveConnectionIdChangedHandler(
     _In_ XblContextHandle xblContext,
     _In_ XblFunctionContext token
 ) XBL_NOEXCEPT
+try
 {
     xblContext->MultiplayerService()->RemoveMultiplayerConnectionIdChangedHandler(token);
-}
\ No newline at end of file
+}
+CATCH_RETURN_WITH(;)
diff --git a/Source/Services/Multiplayer/multiplayer_session.cpp b/Source/Services/Multiplayer/multiplayer_session.cpp
index d1a43bbd..c417b6e3 100644
--- a/Source/Services/Multiplayer/multiplayer_session.cpp
+++ b/Source/Services/Multiplayer/multiplayer_session.cpp
@@ -2476,16 +2476,19 @@ STDAPI_(XblMultiplayerSessionHandle) XblMultiplayerSessionCreateHandle(
     _In_opt_ const XblMultiplayerSessionReference* sessionReference,
     _In_opt_ const XblMultiplayerSessionInitArgs* initArgs
 ) XBL_NOEXCEPT
+try
 {
     auto session = MakeShared<XblMultiplayerSession>(xuid, sessionReference, initArgs);
     session->AddRef();
     return session.get();
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI XblMultiplayerSessionDuplicateHandle(
     _In_ XblMultiplayerSessionHandle session,
     _Out_ XblMultiplayerSessionHandle* duplicatedHandle
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(session == nullptr || duplicatedHandle == nullptr);
 
@@ -2494,28 +2497,34 @@ STDAPI XblMultiplayerSessionDuplicateHandle(
 
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI_(void) XblMultiplayerSessionCloseHandle(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     if (session)
     {
         session->DecRef();
     }
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI_(XblTournamentArbitrationStatus) XblMultiplayerSessionArbitrationStatus(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     UNREFERENCED_PARAMETER(session);
     return XblTournamentArbitrationStatus::Incomplete;
 }
+CATCH_RETURN_WITH(XblTournamentArbitrationStatus::Incomplete)
 
 STDAPI_(time_t) XblMultiplayerSessionTimeOfSession(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2524,10 +2533,12 @@ STDAPI_(time_t) XblMultiplayerSessionTimeOfSession(
 
     return session->TimeOfSession();
 }
+CATCH_RETURN()
 
 STDAPI_(const XblMultiplayerSessionInitializationInfo*) XblMultiplayerSessionGetInitializationInfo(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2536,10 +2547,12 @@ STDAPI_(const XblMultiplayerSessionInitializationInfo*) XblMultiplayerSessionGet
 
     return &session->InitializationInfo();
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI_(XblMultiplayerSessionChangeTypes) XblMultiplayerSessionSubscribedChangeTypes(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2552,12 +2565,14 @@ STDAPI_(XblMultiplayerSessionChangeTypes) XblMultiplayerSessionSubscribedChangeT
     }
     return MultiplayerSessionMember::Get(session->CurrentUserUnsafe())->SubscribedChangeTypes();
 }
+CATCH_RETURN_WITH(XblMultiplayerSessionChangeTypes::None)
 
 STDAPI XblMultiplayerSessionHostCandidates(
     _In_ XblMultiplayerSessionHandle session,
     _Out_ const XblDeviceToken** deviceTokens,
     _Out_ size_t* deviceTokensCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(deviceTokens == nullptr || deviceTokensCount == nullptr);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
@@ -2566,10 +2581,12 @@ STDAPI XblMultiplayerSessionHostCandidates(
     *deviceTokensCount = session->HostCandidates().size();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI_(const XblMultiplayerSessionReference*) XblMultiplayerSessionSessionReference(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2578,10 +2595,12 @@ STDAPI_(const XblMultiplayerSessionReference*) XblMultiplayerSessionSessionRefer
 
     return &session->SessionReference();
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI_(const XblMultiplayerSessionConstants*) XblMultiplayerSessionSessionConstants(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2590,11 +2609,13 @@ STDAPI_(const XblMultiplayerSessionConstants*) XblMultiplayerSessionSessionConst
 
     return &session->SessionConstantsUnsafe();
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI_(void) XblMultiplayerSessionConstantsSetMaxMembersInSession(
     _In_ XblMultiplayerSessionHandle session,
     uint32_t maxMembersInSession
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2603,11 +2624,13 @@ STDAPI_(void) XblMultiplayerSessionConstantsSetMaxMembersInSession(
 
     session->SetMaxMembersInSession(maxMembersInSession);
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI_(void) XblMultiplayerSessionConstantsSetVisibility(
     _In_ XblMultiplayerSessionHandle session,
     _In_ XblMultiplayerSessionVisibility visibility
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2616,6 +2639,7 @@ STDAPI_(void) XblMultiplayerSessionConstantsSetVisibility(
 
     session->SetVisibility(visibility);
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI XblMultiplayerSessionConstantsSetTimeouts(
     _In_ XblMultiplayerSessionHandle session,
@@ -2624,16 +2648,19 @@ STDAPI XblMultiplayerSessionConstantsSetTimeouts(
     _In_ uint64_t memberReadyTimeout,
     _In_ uint64_t sessionEmptyTimeout
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->SetTimeouts(memberReservedTimeout, memberInactiveTimeout, memberReadyTimeout, sessionEmptyTimeout);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionConstantsSetArbitrationTimeouts(
     _In_ XblMultiplayerSessionHandle session,
     _In_ uint64_t arbitrationTimeout,
     _In_ uint64_t forfeitTimeout
 ) XBL_NOEXCEPT
+try
 {
     UNREFERENCED_PARAMETER(session);
     UNREFERENCED_PARAMETER(arbitrationTimeout);
@@ -2641,6 +2668,7 @@ STDAPI XblMultiplayerSessionConstantsSetArbitrationTimeouts(
 
     return E_NOTIMPL;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionConstantsSetQosConnectivityMetrics(
     _In_ XblMultiplayerSessionHandle session,
@@ -2649,68 +2677,83 @@ STDAPI XblMultiplayerSessionConstantsSetQosConnectivityMetrics(
     _In_ bool enableBandwidthUpMetric,
     _In_ bool enableCustomMetric
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->SetQosConnectivityMetrics(enableLatencyMetric, enableBandwidthDownMetric, enableBandwidthUpMetric, enableCustomMetric);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionConstantsSetMemberInitialization(
     _In_ XblMultiplayerSessionHandle session,
     _In_ XblMultiplayerMemberInitialization memberInitialization
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->SetMemberInitialization(std::move(memberInitialization));
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionConstantsSetPeerToPeerRequirements(
     _In_ XblMultiplayerSessionHandle session,
     _In_ XblMultiplayerPeerToPeerRequirements requirements
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->SetPeerToPeerRequirements(std::move(requirements));
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionConstantsSetPeerToHostRequirements(
     _In_ XblMultiplayerSessionHandle session,
     _In_ XblMultiplayerPeerToHostRequirements requirements
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->SetPeerToHostRequirements(std::move(requirements));
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionConstantsSetMeasurementServerAddressesJson(
     _In_ XblMultiplayerSessionHandle session,
     _In_ const char* measurementServerAddressesJson
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(session == nullptr || measurementServerAddressesJson == nullptr);
     return session->SetMeasurementServerAddresses(measurementServerAddressesJson);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionConstantsSetCapabilities(
     _In_ XblMultiplayerSessionHandle session,
     _In_ XblMultiplayerSessionCapabilities capabilities
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->SetSessionCapabilities(std::move(capabilities));
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionConstantsSetCloudComputePackageJson(
     _In_ XblMultiplayerSessionHandle session,
     _In_ const char* sessionCloudComputePackageConstantsJson
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->SetCloudComputePackageJson(sessionCloudComputePackageConstantsJson);
 }
+CATCH_RETURN()
 
 STDAPI_(const XblMultiplayerSessionProperties*) XblMultiplayerSessionSessionProperties(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2719,21 +2762,25 @@ STDAPI_(const XblMultiplayerSessionProperties*) XblMultiplayerSessionSessionProp
 
     return &session->SessionPropertiesUnsafe();
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI XblMultiplayerSessionPropertiesSetKeywords(
     _In_ XblMultiplayerSessionHandle session,
     _In_ const char** keywords,
     _In_ size_t keywordsCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->SetKeywords(keywords, keywordsCount);
 }
+CATCH_RETURN()
 
 STDAPI_(void) XblMultiplayerSessionPropertiesSetJoinRestriction(
     _In_ XblMultiplayerSessionHandle session,
     _In_ XblMultiplayerSessionRestriction joinRestriction
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2742,11 +2789,13 @@ STDAPI_(void) XblMultiplayerSessionPropertiesSetJoinRestriction(
 
     session->SetJoinRestriction(joinRestriction);
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI_(void) XblMultiplayerSessionPropertiesSetReadRestriction(
     _In_ XblMultiplayerSessionHandle session,
     _In_ XblMultiplayerSessionRestriction readRestriction
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2755,22 +2804,26 @@ STDAPI_(void) XblMultiplayerSessionPropertiesSetReadRestriction(
 
     session->SetReadRestriction(readRestriction);
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI XblMultiplayerSessionPropertiesSetTurnCollection(
     _In_ XblMultiplayerSessionHandle session,
     _In_ const uint32_t* turnCollectionMemberIds,
     _In_ size_t turnCollectionMemberIdsCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->SetTurnCollection(xsapi_internal_vector<uint32_t>(turnCollectionMemberIds, turnCollectionMemberIds + turnCollectionMemberIdsCount));
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionRoleTypes(
     _In_ XblMultiplayerSessionHandle session,
     _Out_ const XblMultiplayerRoleType** roleTypes,
     _Out_ size_t* roleTypesCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     RETURN_HR_INVALIDARGUMENT_IF(roleTypes == nullptr || roleTypesCount == nullptr);
@@ -2779,6 +2832,7 @@ STDAPI XblMultiplayerSessionRoleTypes(
     *roleTypesCount = session->RoleTypesUnsafe().Values().size();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionGetRoleByName(
     _In_ XblMultiplayerSessionHandle session,
@@ -2786,12 +2840,14 @@ STDAPI XblMultiplayerSessionGetRoleByName(
     _In_z_ const char* roleName,
     _Out_ const XblMultiplayerRole** role
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     RETURN_HR_INVALIDARGUMENT_IF(roleTypeName == nullptr || roleName == nullptr || role == nullptr);
     *role = session->RoleTypesUnsafe().GetRole(roleTypeName, roleName);
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionSetMutableRoleSettings(
     _In_ XblMultiplayerSessionHandle session,
@@ -2800,17 +2856,20 @@ STDAPI XblMultiplayerSessionSetMutableRoleSettings(
     _In_opt_ uint32_t* maxMemberCount,
     _In_opt_ uint32_t* targetMemberCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     RETURN_HR_INVALIDARGUMENT_IF(roleTypeName == nullptr || roleName == nullptr);
     return session->SetMutableRoleSettings(roleTypeName, roleName, maxMemberCount, targetMemberCount);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionMembers(
     _In_ XblMultiplayerSessionHandle session,
     _Out_ const XblMultiplayerSessionMember** members,
     _Out_ size_t* membersCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     RETURN_HR_INVALIDARGUMENT_IF(members == nullptr || membersCount == nullptr);
@@ -2819,11 +2878,13 @@ STDAPI XblMultiplayerSessionMembers(
     *membersCount = session->MembersUnsafe().size();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI_(const XblMultiplayerSessionMember*) XblMultiplayerSessionGetMember(
     _In_ XblMultiplayerSessionHandle session,
     _In_ uint32_t memberId
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2841,10 +2902,12 @@ STDAPI_(const XblMultiplayerSessionMember*) XblMultiplayerSessionGetMember(
     }
     return nullptr;
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI_(const XblMultiplayerMatchmakingServer*) XblMultiplayerSessionMatchmakingServer(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2853,16 +2916,19 @@ STDAPI_(const XblMultiplayerMatchmakingServer*) XblMultiplayerSessionMatchmaking
 
     return session->MatchmakingServer().get();
 }
+CATCH_RETURN_WITH(nullptr)
 
 XBL_WARNING_PUSH
 XBL_WARNING_DISABLE_DEPRECATED
 STDAPI_(const XblMultiplayerTournamentsServer*) XblMultiplayerSessionTournamentsServer(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     UNREFERENCED_PARAMETER(session);
     return nullptr;
 }
+CATCH_RETURN_WITH(nullptr)
 XBL_WARNING_POP
 
 XBL_WARNING_PUSH
@@ -2870,15 +2936,18 @@ XBL_WARNING_DISABLE_DEPRECATED
 STDAPI_(const XblMultiplayerArbitrationServer*) XblMultiplayerSessionArbitrationServer(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     UNREFERENCED_PARAMETER(session);
     return nullptr;
 }
+CATCH_RETURN_WITH(nullptr)
 XBL_WARNING_POP
 
 STDAPI_(uint32_t) XblMultiplayerSessionMembersAccepted(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2887,10 +2956,12 @@ STDAPI_(uint32_t) XblMultiplayerSessionMembersAccepted(
 
     return session->MembersAccepted();
 }
+CATCH_RETURN()
 
 STDAPI_(const char*) XblMultiplayerSessionRawServersJson(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2899,19 +2970,23 @@ STDAPI_(const char*) XblMultiplayerSessionRawServersJson(
 
     return session->RawServersJsonUnsafe().data();
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI XblMultiplayerSessionSetRawServersJson(
     _In_ XblMultiplayerSessionHandle session,
     _In_z_ const char* rawServersJson
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->SetServersJson(rawServersJson);
 }
+CATCH_RETURN()
 
 STDAPI_(const char*) XblMultiplayerSessionEtag(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2920,10 +2995,12 @@ STDAPI_(const char*) XblMultiplayerSessionEtag(
 
     return session->ETagUnsafe().data();
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI_(const XblMultiplayerSessionMember*) XblMultiplayerSessionCurrentUser(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2932,10 +3009,12 @@ STDAPI_(const XblMultiplayerSessionMember*) XblMultiplayerSessionCurrentUser(
 
     return session->CurrentUserUnsafe();
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI_(const XblMultiplayerSessionInfo*) XblMultiplayerSessionGetInfo(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2944,10 +3023,12 @@ STDAPI_(const XblMultiplayerSessionInfo*) XblMultiplayerSessionGetInfo(
 
     return &session->SessionInfo();
 }
+CATCH_RETURN_WITH(nullptr)
 
 STDAPI_(XblWriteSessionStatus) XblMultiplayerSessionWriteStatus(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2959,6 +3040,7 @@ STDAPI_(XblWriteSessionStatus) XblMultiplayerSessionWriteStatus(
         return session->WriteStatus();
     }
 }
+CATCH_RETURN_WITH(XblWriteSessionStatus::Unknown)
 
 STDAPI XblMultiplayerSessionAddMemberReservation(
     _In_ XblMultiplayerSessionHandle session,
@@ -2966,10 +3048,12 @@ STDAPI XblMultiplayerSessionAddMemberReservation(
     _In_opt_z_ const char* memberCustomConstantsJson,
     _In_ bool initializeRequested
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->AddMemberReservation(xuid, memberCustomConstantsJson, initializeRequested);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionJoin(
     _In_ XblMultiplayerSessionHandle session,
@@ -2977,15 +3061,18 @@ STDAPI XblMultiplayerSessionJoin(
     _In_ bool initializeRequested,
     _In_ bool joinWithActiveStatus
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->Join(memberCustomConstantsJson, initializeRequested, joinWithActiveStatus);
 }
+CATCH_RETURN()
 
 STDAPI_(void) XblMultiplayerSessionSetInitializationSucceeded(
     _In_ XblMultiplayerSessionHandle session,
     _In_ bool initializationSucceeded
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -2994,11 +3081,13 @@ STDAPI_(void) XblMultiplayerSessionSetInitializationSucceeded(
 
     session->SetInitializationStatus(initializationSucceeded);
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI_(void) XblMultiplayerSessionSetHostDeviceToken(
     _In_ XblMultiplayerSessionHandle session,
     _In_ XblDeviceToken hostDeviceToken
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -3007,11 +3096,13 @@ STDAPI_(void) XblMultiplayerSessionSetHostDeviceToken(
 
     session->SetHostDeviceToken(hostDeviceToken);
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI_(void) XblMultiplayerSessionSetMatchmakingServerConnectionPath(
     _In_ XblMultiplayerSessionHandle session,
     _In_z_ const char* serverConnectionPath
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -3020,11 +3111,13 @@ STDAPI_(void) XblMultiplayerSessionSetMatchmakingServerConnectionPath(
 
     return session->SetMatchmakingServerConnectionPath(serverConnectionPath);
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI_(void) XblMultiplayerSessionSetClosed(
     _In_ XblMultiplayerSessionHandle session,
     _In_ bool closed
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -3033,11 +3126,13 @@ STDAPI_(void) XblMultiplayerSessionSetClosed(
 
     session->SetClosed(closed);
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI_(void) XblMultiplayerSessionSetLocked(
     _In_ XblMultiplayerSessionHandle session,
     _In_ bool locked
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -3046,11 +3141,13 @@ STDAPI_(void) XblMultiplayerSessionSetLocked(
 
     session->SetLocked(locked);
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI_(void) XblMultiplayerSessionSetAllocateCloudCompute(
     _In_ XblMultiplayerSessionHandle session,
     _In_ bool allocateCloudCompute
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -3059,11 +3156,13 @@ STDAPI_(void) XblMultiplayerSessionSetAllocateCloudCompute(
 
     session->SetAllocateCloudCompute(allocateCloudCompute);
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI_(void) XblMultiplayerSessionSetMatchmakingResubmit(
     _In_ XblMultiplayerSessionHandle session,
     _In_ bool matchResubmit
 ) XBL_NOEXCEPT
+try
 {
     if (session == nullptr)
     {
@@ -3072,57 +3171,69 @@ STDAPI_(void) XblMultiplayerSessionSetMatchmakingResubmit(
 
     session->SetMatchmakingResubmit(matchResubmit);
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI XblMultiplayerSessionSetServerConnectionStringCandidates(
     _In_ XblMultiplayerSessionHandle session,
     _In_reads_(serverConnectionStringCandidatesCount) const char** serverConnectionStringCandidates,
     _In_ size_t serverConnectionStringCandidatesCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->SetServerConnectionStringCandidates(serverConnectionStringCandidates, serverConnectionStringCandidatesCount);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionSetSessionChangeSubscription(
     _In_ XblMultiplayerSessionHandle session,
     _In_ XblMultiplayerSessionChangeTypes changeTypes
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->SetSessionChangeSubscription(changeTypes);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionLeave(
     _In_ XblMultiplayerSessionHandle session
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->Leave();
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionCurrentUserSetStatus(
     _In_ XblMultiplayerSessionHandle session,
     _In_ XblMultiplayerSessionMemberStatus status
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->SetCurrentUserStatus(status);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionCurrentUserSetSecureDeviceAddressBase64(
     _In_ XblMultiplayerSessionHandle session,
     _In_ const char* value
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     return session->SetCurrentUserSecureDeviceAddressBase64(value);
 }
+CATCH_RETURN()
 
 #if HC_PLATFORM != HC_PLATFORM_XDK && HC_PLATFORM != HC_PLATFORM_UWP
 STDAPI XblFormatSecureDeviceAddress(
     _In_ const char* deviceId,
     _Inout_ XblFormattedSecureDeviceAddress* address
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(address);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(deviceId);
@@ -3132,6 +3243,7 @@ STDAPI XblFormatSecureDeviceAddress(
     utils::strcpy(address->value, sizeof(address->value), sda.c_str());
     return S_OK;
 }
+CATCH_RETURN()
 #endif
 
 STDAPI XblMultiplayerSessionCurrentUserSetRoles(
@@ -3139,70 +3251,83 @@ STDAPI XblMultiplayerSessionCurrentUserSetRoles(
     _In_ const XblMultiplayerSessionMemberRole* roles,
     _In_ size_t rolesCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(roles);
     return session->SetCurrentUserRoleInfo(xsapi_internal_vector<XblMultiplayerSessionMemberRole>(roles, roles + rolesCount));
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionCurrentUserSetMembersInGroup(
     _In_ XblMultiplayerSessionHandle session,
     _In_reads_(memberIdsCount) uint32_t* memberIds,
     _In_ size_t memberIdsCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(memberIds);
     return session->SetCurrentUserMembersInGroup(xsapi_internal_vector<uint32_t>(memberIds, memberIds + memberIdsCount));
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionCurrentUserSetGroups(
     _In_ XblMultiplayerSessionHandle session,
     _In_reads_(groupsCount) const char** groups,
     _In_ size_t groupsCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(groups);
     return session->SetCurrentUserGroups(groups, groupsCount);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionCurrentUserSetEncounters(
     _In_ XblMultiplayerSessionHandle session,
     _In_reads_(encountersCount) const char** encounters,
     _In_ size_t encountersCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(encounters);
     return session->SetCurrentUserEncounters(encounters, encountersCount);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionCurrentUserSetQosMeasurements(
     _In_ XblMultiplayerSessionHandle session,
     _In_z_ const char* measurements
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(measurements);
     return session->SetCurrentUserQosMeasurementsJson(measurements);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionCurrentUserSetServerQosMeasurements(
     _In_ XblMultiplayerSessionHandle session,
     _In_z_ const char* measurements
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(measurements);
     return session->SetCurrentUserServerMeasurementsJson(measurements);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionCurrentUserSetCustomPropertyJson(
     _In_ XblMultiplayerSessionHandle session,
     _In_z_ const char* name,
     _In_z_ const char* valueJson
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     RETURN_HR_INVALIDARGUMENT_IF(name == nullptr || valueJson == nullptr);
@@ -3215,31 +3340,37 @@ STDAPI XblMultiplayerSessionCurrentUserSetCustomPropertyJson(
     }
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionCurrentUserDeleteCustomPropertyJson(
     _In_ XblMultiplayerSessionHandle session,
     _In_z_ const char* name
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(name);
     return session->DeleteCurrentUserMemberCustomPropertyJson(name);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionSetMatchmakingTargetSessionConstantsJson(
     _In_ XblMultiplayerSessionHandle session,
     _In_ const char* matchmakingTargetSessionConstantsJson
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(session == nullptr || matchmakingTargetSessionConstantsJson == nullptr);
     return session->SetMatchmakingTargetSessionConstantsJson(matchmakingTargetSessionConstantsJson);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionSetCustomPropertyJson(
     _In_ XblMultiplayerSessionHandle session,
     _In_z_ const char* name,
     _In_z_ const char* valueJson
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     RETURN_HR_INVALIDARGUMENT_IF(name == nullptr || valueJson == nullptr);
@@ -3252,21 +3383,25 @@ STDAPI XblMultiplayerSessionSetCustomPropertyJson(
     }
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionDeleteCustomPropertyJson(
     _In_ XblMultiplayerSessionHandle session,
     _In_z_ const char* name
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(session);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(name);
     return session->DeleteSessionCustomPropertyJson(name);
 }
+CATCH_RETURN()
 
 STDAPI_(XblMultiplayerSessionChangeTypes) XblMultiplayerSessionCompare(
     _In_ XblMultiplayerSessionHandle currentSessionHandle,
     _In_ XblMultiplayerSessionHandle oldSessionHandle
 ) XBL_NOEXCEPT
+try
 {
     if (currentSessionHandle == nullptr || oldSessionHandle == nullptr)
     {
@@ -3274,3 +3409,4 @@ STDAPI_(XblMultiplayerSessionChangeTypes) XblMultiplayerSessionCompare(
     }
     return currentSessionHandle->CompareMultiplayerSessions(oldSessionHandle->shared_from_this());
 }
+CATCH_RETURN_WITH(XblMultiplayerSessionChangeTypes::None)
diff --git a/Source/Services/Multiplayer/multiplayer_session_reference.cpp b/Source/Services/Multiplayer/multiplayer_session_reference.cpp
index 05ec047b..931a25a9 100644
--- a/Source/Services/Multiplayer/multiplayer_session_reference.cpp
+++ b/Source/Services/Multiplayer/multiplayer_session_reference.cpp
@@ -13,6 +13,7 @@ STDAPI XblMultiplayerSessionReferenceParseFromUriPath(
     _In_ const char* path,
     _Out_ XblMultiplayerSessionReference* ref
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(ref);
 
@@ -32,11 +33,13 @@ STDAPI XblMultiplayerSessionReferenceParseFromUriPath(
 
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerSessionReferenceToUriPath(
     _In_ const XblMultiplayerSessionReference* sessionReference,
     _Out_ XblMultiplayerSessionReferenceUri* sessionReferenceUri
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(sessionReference == nullptr || sessionReferenceUri == nullptr);
 
@@ -53,6 +56,7 @@ STDAPI XblMultiplayerSessionReferenceToUriPath(
 
     return S_OK;
 }
+CATCH_RETURN()
 
 /// <summary>
 /// Checks whether an XblMultiplayerSessionReference is well formed. It is considered well formed if none of the
@@ -61,6 +65,7 @@ STDAPI XblMultiplayerSessionReferenceToUriPath(
 STDAPI_(bool) XblMultiplayerSessionReferenceIsValid(
     _In_ const XblMultiplayerSessionReference* sessionReference
 ) XBL_NOEXCEPT
+try
 {
     if (sessionReference == nullptr)
     {
@@ -68,6 +73,7 @@ STDAPI_(bool) XblMultiplayerSessionReferenceIsValid(
     }
     return sessionReference->Scid[0] != 0 && sessionReference->SessionTemplateName[0] != 0 && sessionReference->SessionName[0] != 0;
 }
+CATCH_RETURN()
 
 /// <summary>
 /// Creates an XblMultiplayerSessionReference from a scid, session template name, and session name.
@@ -77,6 +83,7 @@ STDAPI_(XblMultiplayerSessionReference) XblMultiplayerSessionReferenceCreate(
     _In_z_ const char* sessionTemplateName,
     _In_z_ const char* sessionName
 ) XBL_NOEXCEPT
+try
 {
     XblMultiplayerSessionReference out{};
     if (scid != nullptr)
@@ -93,6 +100,7 @@ STDAPI_(XblMultiplayerSessionReference) XblMultiplayerSessionReferenceCreate(
     }
     return out;
 }
+CATCH_RETURN_WITH({})
 
 NAMESPACE_MICROSOFT_XBOX_SERVICES_MULTIPLAYER_CPP_BEGIN
 
diff --git a/Source/Services/MultiplayerActivity/multiplayer_activity_api.cpp b/Source/Services/MultiplayerActivity/multiplayer_activity_api.cpp
index 6d47df35..81ab1786 100644
--- a/Source/Services/MultiplayerActivity/multiplayer_activity_api.cpp
+++ b/Source/Services/MultiplayerActivity/multiplayer_activity_api.cpp
@@ -19,15 +19,18 @@ STDAPI XblMultiplayerActivityUpdateRecentPlayers(
     _In_reads_(updatesCount) const XblMultiplayerActivityRecentPlayerUpdate* updates,
     _In_ size_t updatesCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr);
     return xblContextHandle->MultiplayerActivityService()->UpdateRecentPlayers(updates, updatesCount);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerActivityFlushRecentPlayersAsync(
     _In_ XblContextHandle xblContextHandle,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr);
 
@@ -51,6 +54,7 @@ STDAPI XblMultiplayerActivityFlushRecentPlayersAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerActivitySetActivityAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -58,6 +62,7 @@ STDAPI XblMultiplayerActivitySetActivityAsync(
     _In_ bool allowCrossPlatformJoin,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || activityInfo == nullptr || activityInfo->connectionString ==  nullptr);
 
@@ -83,6 +88,7 @@ STDAPI XblMultiplayerActivitySetActivityAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerActivityGetActivityAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -90,6 +96,7 @@ STDAPI XblMultiplayerActivityGetActivityAsync(
     _In_ size_t xuidsCount,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || xuidsPtr == nullptr || xuidsCount == 0);
 
@@ -190,14 +197,17 @@ STDAPI XblMultiplayerActivityGetActivityAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerActivityGetActivityResultSize(
     _In_ XAsyncBlock* async,
     _Out_ size_t* resultSizeInBytes
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResultSize(async, resultSizeInBytes);
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerActivityGetActivityResult(
     _In_ XAsyncBlock* async,
@@ -207,6 +217,7 @@ STDAPI XblMultiplayerActivityGetActivityResult(
     _Out_ size_t* resultCount,
     _Out_opt_ size_t* bufferUsed
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(results == nullptr || resultCount == nullptr);
 
@@ -219,11 +230,13 @@ STDAPI XblMultiplayerActivityGetActivityResult(
     }
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerActivityDeleteActivityAsync(
     _In_ XblContextHandle xblContextHandle,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xblContextHandle);
 
@@ -247,6 +260,7 @@ STDAPI XblMultiplayerActivityDeleteActivityAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerActivitySendInvitesAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -256,6 +270,7 @@ STDAPI XblMultiplayerActivitySendInvitesAsync(
     _In_opt_z_ const char* _connectionString,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || xuidsPtr == nullptr || xuidsCount == 0);
 
@@ -282,6 +297,7 @@ STDAPI XblMultiplayerActivitySendInvitesAsync(
         }
     });
 }
+CATCH_RETURN()
 
 #if (HC_PLATFORM == HC_PLATFORM_WIN32 || HC_PLATFORM_IS_EXTERNAL) && !XSAPI_UNIT_TESTS
 STDAPI_(XblFunctionContext) XblMultiplayerActivityAddInviteHandler(
@@ -289,6 +305,7 @@ STDAPI_(XblFunctionContext) XblMultiplayerActivityAddInviteHandler(
     _In_ XblMultiplayerActivityInviteHandler* handler,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     if (xblContext == nullptr || handler == nullptr)
     {
@@ -313,15 +330,18 @@ STDAPI_(XblFunctionContext) XblMultiplayerActivityAddInviteHandler(
     } 
     });
 }
+CATCH_RETURN()
 
 STDAPI XblMultiplayerActivityRemoveInviteHandler(
     _In_ XblContextHandle xblContext,
     _In_ XblFunctionContext token
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xblContext);
     auto rtaNotificationService = std::dynamic_pointer_cast<RTANotificationService>(xblContext->NotificationService());
     rtaNotificationService->RemoveNotificationHandler(token);
     return S_OK;
 }
+CATCH_RETURN()
 #endif
diff --git a/Source/Services/MultiplayerActivity/multiplayer_activity_internal.h b/Source/Services/MultiplayerActivity/multiplayer_activity_internal.h
index 2e3cc5d8..b1c6176c 100644
--- a/Source/Services/MultiplayerActivity/multiplayer_activity_internal.h
+++ b/Source/Services/MultiplayerActivity/multiplayer_activity_internal.h
@@ -79,6 +79,7 @@ class MultiplayerActivityService : public std::enable_shared_from_this<Multiplay
     UnorderedMap<uint64_t, RecentPlayerUpdateMetadata> m_pendingRecentPlayerUpdates{};
     bool m_recentPlayersUpdateScheduled{ false };
 
+    static uint64_t GetSequenceNumber();
     void ScheduleRecentPlayersUpdate() noexcept;
     static XblMultiplayerActivityPlatform GetLocalPlatform() noexcept;
 
diff --git a/Source/Services/MultiplayerActivity/multiplayer_activity_service.cpp b/Source/Services/MultiplayerActivity/multiplayer_activity_service.cpp
index 13253a3d..0c7540a7 100644
--- a/Source/Services/MultiplayerActivity/multiplayer_activity_service.cpp
+++ b/Source/Services/MultiplayerActivity/multiplayer_activity_service.cpp
@@ -206,6 +206,22 @@ HRESULT MultiplayerActivityService::FlushRecentPlayers(
     return S_OK;
 }
 
+uint64_t MultiplayerActivityService::GetSequenceNumber()
+{
+    uint64_t dateTime = xbox::services::datetime::utc_now().to_interval(); // eg. 131472330440000000
+    const uint64_t dateTimeFromJan1st2015 = 130645440000000000;
+    if (dateTime < dateTimeFromJan1st2015)
+    {
+        return static_cast<int64_t>(time(nullptr)); // Clock is wrong and is not yet sync'd with internet time so just revert to old logic
+    }
+    else
+    {
+        uint64_t dateTimeSince2015 = dateTime - dateTimeFromJan1st2015; // eg. 826888900000000
+        uint64_t dateTimeTrimmed = dateTimeSince2015 >> 16; // divide by 2^16 to get it to sub second range.  eg. 12617323303
+        return dateTimeTrimmed;
+    }
+}
+
 HRESULT MultiplayerActivityService::SetActivity(
     _In_ const ActivityInfo& info,
     _In_ bool allowCrossPlatformJoin,
@@ -218,7 +234,7 @@ HRESULT MultiplayerActivityService::SetActivity(
     JsonDocument requestBody{ rapidjson::kObjectType };
     auto& a{ requestBody.GetAllocator() };
 
-    requestBody.AddMember("sequenceNumber", static_cast<int64_t>(time(nullptr)), a);
+    requestBody.AddMember("sequenceNumber", GetSequenceNumber(), a);
     requestBody.AddMember("connectionString", JsonValue{ info.connectionString.data(), a }, a);
     requestBody.AddMember("joinRestriction", JsonValue{ EnumName(info.joinRestriction).data(), a }, a);
     if (info.maxPlayers)
@@ -320,7 +336,7 @@ HRESULT MultiplayerActivityService::DeleteActivity(
     JsonDocument requestBody{ rapidjson::kObjectType };
     auto& a{ requestBody.GetAllocator() };
 
-    requestBody.AddMember("sequenceNumber", static_cast<int64_t>(time(nullptr)), a);
+    requestBody.AddMember("sequenceNumber", GetSequenceNumber(), a);
 
     Result<User> userResult = m_user.Copy();
     RETURN_HR_IF_FAILED(userResult.Hresult());
diff --git a/Source/Services/Notification/notification_api.cpp b/Source/Services/Notification/notification_api.cpp
index a7d37a37..e8c57d55 100644
--- a/Source/Services/Notification/notification_api.cpp
+++ b/Source/Services/Notification/notification_api.cpp
@@ -15,6 +15,7 @@ STDAPI XblNotificationSubscribeToNotificationsAsync(
     _In_ XAsyncBlock* asyncBlock,
     _In_ const char* registrationToken
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(registrationToken == nullptr || strlen(registrationToken) <= 1);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xboxLiveContext);
@@ -54,6 +55,7 @@ STDAPI XblNotificationSubscribeToNotificationsAsync(
         }
     });
 }
+CATCH_RETURN()
 
 /// <summary>
 /// Unsubscribes title from push notifications.
@@ -62,6 +64,7 @@ STDAPI XblNotificationUnsubscribeFromNotificationsAsync(
     _In_ XblContextHandle xboxLiveContext,
     _In_ XAsyncBlock* asyncBlock
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xboxLiveContext);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(asyncBlock);
@@ -98,11 +101,15 @@ STDAPI XblNotificationUnsubscribeFromNotificationsAsync(
         }
     });
 }
+CATCH_RETURN()
+
 #elif HC_PLATFORM == HC_PLATFORM_UWP
+
 STDAPI XblNotificationSubscribeToNotificationsAsync(
     _In_ XblContextHandle xboxLiveContext,
     _In_ XAsyncBlock* asyncBlock
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xboxLiveContext);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(asyncBlock);
@@ -138,6 +145,7 @@ STDAPI XblNotificationSubscribeToNotificationsAsync(
         }
     });
 }
+CATCH_RETURN()
 
 /// <summary>
 /// Ubsubscribes title from push notifications.
@@ -146,6 +154,7 @@ STDAPI XblNotificationUnsubscribeFromNotificationsAsync(
     _In_ XblContextHandle xboxLiveContext,
     _In_ XAsyncBlock* asyncBlock
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xboxLiveContext);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(asyncBlock);
@@ -182,11 +191,15 @@ STDAPI XblNotificationUnsubscribeFromNotificationsAsync(
         }
     });
 }
+CATCH_RETURN()
+
 #elif HC_PLATFORM == HC_PLATFORM_WIN32 || HC_PLATFORM_IS_EXTERNAL
+
 STDAPI XblGameInviteRegisterForEventAsync(
     _In_ XblContextHandle xboxLiveContext,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xboxLiveContext);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(async);
@@ -215,11 +228,13 @@ STDAPI XblGameInviteRegisterForEventAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblGameInviteRegisterForEventResult(
     _In_ XAsyncBlock* async,
     _Out_ XblRealTimeActivitySubscriptionHandle* handle
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(async);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(handle);
@@ -238,12 +253,14 @@ STDAPI XblGameInviteRegisterForEventResult(
 
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblGameInviteUnregisterForEventAsync(
     _In_ XblContextHandle xblContextHandle,
     _In_ XblRealTimeActivitySubscriptionHandle subscriptionHandle,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || subscriptionHandle == nullptr);
 
@@ -266,12 +283,14 @@ STDAPI XblGameInviteUnregisterForEventAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI_(XblFunctionContext) XblGameInviteAddNotificationHandler(
     _In_ XblContextHandle xblContextHandle,
     _In_ XblGameInviteHandler* handler,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     // TODO really should be returning HRESULT E_INVALIDARG here
     if (xblContextHandle == nullptr || handler == nullptr)
@@ -297,11 +316,13 @@ STDAPI_(XblFunctionContext) XblGameInviteAddNotificationHandler(
     }
     });
 }
+CATCH_RETURN()
 
 STDAPI_(void) XblGameInviteRemoveNotificationHandler(
     _In_ XblContextHandle xblContextHandle,
     _In_ XblFunctionContext token
 ) XBL_NOEXCEPT
+try
 {
     if (xblContextHandle)
     {
@@ -309,13 +330,14 @@ STDAPI_(void) XblGameInviteRemoveNotificationHandler(
         rtaNotificationService->RemoveNotificationHandler(token);
     }
 }
-
+CATCH_RETURN_WITH(;)
 
 STDAPI_(XblFunctionContext) XblAchievementUnlockAddNotificationHandler(
     _In_ XblContextHandle xblContextHandle,
     _In_ XblAchievementUnlockHandler* handler,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     // TODO really should be returning HRESULT E_INVALIDARG here
     if (xblContextHandle == nullptr || handler == nullptr)
@@ -338,16 +360,17 @@ STDAPI_(XblFunctionContext) XblAchievementUnlockAddNotificationHandler(
             }
         });
 }
-
+CATCH_RETURN()
 
 STDAPI_(void) XblAchievementUnlockRemoveNotificationHandler(
     _In_ XblContextHandle xblContextHandle,
     _In_ XblFunctionContext functionContext
 ) XBL_NOEXCEPT
+try
 {
     auto rtaNotificationService = std::dynamic_pointer_cast<RTANotificationService>(xblContextHandle->NotificationService());
     rtaNotificationService->RemoveNotificationHandler(functionContext);
 }
-
+CATCH_RETURN_WITH(;)
 
 #endif
diff --git a/Source/Services/Presence/presence_api.cpp b/Source/Services/Presence/presence_api.cpp
index 9b35bae6..d08be219 100644
--- a/Source/Services/Presence/presence_api.cpp
+++ b/Source/Services/Presence/presence_api.cpp
@@ -14,27 +14,32 @@ STDAPI XblPresenceRecordGetXuid(
     _In_ XblPresenceRecordHandle record,
     _Out_ uint64_t* xuid
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(record == nullptr || xuid == nullptr);
     *xuid = record->Xuid();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceRecordGetUserState(
     _In_ XblPresenceRecordHandle record,
     _Out_ XblPresenceUserState* userState
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(record == nullptr || userState == nullptr);
     *userState = record->UserState();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceRecordGetDeviceRecords(
     _In_ XblPresenceRecordHandle record,
     _Out_ const XblPresenceDeviceRecord** deviceRecords,
     _Out_ size_t* deviceRecordsCount
 ) XBL_NOEXCEPT 
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(record == nullptr || deviceRecords == nullptr || deviceRecordsCount == nullptr);
 
@@ -42,11 +47,13 @@ STDAPI XblPresenceRecordGetDeviceRecords(
     *deviceRecordsCount = record->DeviceRecords().size();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceRecordDuplicateHandle(
     _In_ XblPresenceRecordHandle record,
     _Out_ XblPresenceRecordHandle* duplicatedHandle
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(record == nullptr || duplicatedHandle == nullptr);
 
@@ -55,16 +62,19 @@ STDAPI XblPresenceRecordDuplicateHandle(
 
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI_(void) XblPresenceRecordCloseHandle(
     _In_ XblPresenceRecordHandle record
 ) XBL_NOEXCEPT
+try
 {
     if (record)
     {
         record->DecRef();
     }
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI XblPresenceSetPresenceAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -72,6 +82,7 @@ STDAPI XblPresenceSetPresenceAsync(
     _In_opt_ XblPresenceRichPresenceIds* richPresenceIds,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || async == nullptr);
     VERIFY_XBL_INITIALIZED();
@@ -100,12 +111,14 @@ STDAPI XblPresenceSetPresenceAsync(
         } // end switch
     });
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceGetPresenceAsync(
     _In_ XblContextHandle xblContextHandle,
     _In_ uint64_t xuid,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || async == nullptr);
     VERIFY_XBL_INITIALIZED();
@@ -154,20 +167,24 @@ STDAPI XblPresenceGetPresenceAsync(
         } // end switch
     });
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceGetPresenceResult(
     _In_ XAsyncBlock* async,
     _Out_ XblPresenceRecordHandle* presenceRecordHandle
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResult(async, nullptr, sizeof(XblPresenceRecordHandle), presenceRecordHandle, nullptr);
 }
+CATCH_RETURN()
 
 STDAPI GetBatchPresenceProvider(
     _In_ XblContextHandle xblContextHandle,
     _In_ UserBatchRequest&& request,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     return RunAsync(async, __FUNCTION__,
         [
@@ -216,6 +233,7 @@ STDAPI GetBatchPresenceProvider(
         } // end switch
     });
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceGetPresenceForMultipleUsersAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -224,6 +242,7 @@ STDAPI XblPresenceGetPresenceForMultipleUsersAsync(
     _In_opt_ XblPresenceQueryFilters* filters,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || xuids == nullptr || async == nullptr);
     VERIFY_XBL_INITIALIZED();
@@ -234,11 +253,13 @@ STDAPI XblPresenceGetPresenceForMultipleUsersAsync(
         async
     );
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceGetPresenceForMultipleUsersResultCount(
     _In_ XAsyncBlock* async,
     _Out_ size_t* resultCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(resultCount);
 
@@ -251,18 +272,21 @@ STDAPI XblPresenceGetPresenceForMultipleUsersResultCount(
     }
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceGetPresenceForMultipleUsersResult(
     _In_ XAsyncBlock* async,
     _Out_writes_(presenceRecordHandlesCount) XblPresenceRecordHandle* presenceRecordHandles,
     _In_ size_t presenceRecordHandlesCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_IF(presenceRecordHandlesCount == 0, S_OK);
     RETURN_HR_INVALIDARGUMENT_IF(presenceRecordHandles == nullptr);
 
     return XAsyncGetResult(async, nullptr, sizeof(XblPresenceRecordHandle) * presenceRecordHandlesCount, presenceRecordHandles, nullptr);
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceGetPresenceForSocialGroupAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -271,6 +295,7 @@ STDAPI XblPresenceGetPresenceForSocialGroupAsync(
     _In_opt_ XblPresenceQueryFilters* filters,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || socialGroupName == nullptr || async == nullptr);
     VERIFY_XBL_INITIALIZED();
@@ -281,23 +306,28 @@ STDAPI XblPresenceGetPresenceForSocialGroupAsync(
         async
     );
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceGetPresenceForSocialGroupResultCount(
     _In_ XAsyncBlock* async,
     _Out_ size_t* resultCount
 ) XBL_NOEXCEPT
+try
 {
     return XblPresenceGetPresenceForMultipleUsersResultCount(async, resultCount);
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceGetPresenceForSocialGroupResult(
     _In_ XAsyncBlock* async,
     _Out_ XblPresenceRecordHandle* presenceRecordHandles,
     _In_ size_t presenceRecordHandlesCount
 ) XBL_NOEXCEPT
+try
 {
     return XblPresenceGetPresenceForMultipleUsersResult(async, presenceRecordHandles, presenceRecordHandlesCount);
 }
+CATCH_RETURN()
 
 namespace xbox {
     namespace services {
@@ -364,6 +394,7 @@ STDAPI XblPresenceSubscribeToDevicePresenceChange(
     _In_ uint64_t xuid,
     _Out_ XblRealTimeActivitySubscriptionHandle* subscriptionHandle
 ) XBL_NOEXCEPT
+try
 {
     INIT_OUT_PTR_PARAM(subscriptionHandle);
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || subscriptionHandle == nullptr);
@@ -371,17 +402,20 @@ STDAPI XblPresenceSubscribeToDevicePresenceChange(
     *subscriptionHandle = Make<presence::legacy::Subscription>(xblContextHandle->PresenceService(), xuid);
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceUnsubscribeFromDevicePresenceChange(
     _In_ XblContextHandle xblContextHandle,
     _In_ XblRealTimeActivitySubscriptionHandle subscriptionHandle
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || subscriptionHandle == nullptr);
 
     Delete(subscriptionHandle);
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceSubscribeToTitlePresenceChange(
     _In_ XblContextHandle xblContextHandle,
@@ -389,6 +423,7 @@ STDAPI XblPresenceSubscribeToTitlePresenceChange(
     _In_ uint32_t titleId,
     _Out_ XblRealTimeActivitySubscriptionHandle* subscriptionHandle
 ) XBL_NOEXCEPT
+try
 {
     INIT_OUT_PTR_PARAM(subscriptionHandle);
     RETURN_HR_INVALIDARGUMENT_IF(xblContextHandle == nullptr || subscriptionHandle == nullptr);
@@ -396,23 +431,27 @@ STDAPI XblPresenceSubscribeToTitlePresenceChange(
     *subscriptionHandle = Make<presence::legacy::TitleSubscription>(xblContextHandle->PresenceService(), xuid, titleId);
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceUnsubscribeFromTitlePresenceChange(
     _In_ XblContextHandle xblContext,
     _In_ XblRealTimeActivitySubscriptionHandle subscriptionHandle
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContext == nullptr || subscriptionHandle == nullptr);
 
     Delete(subscriptionHandle);
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI_(XblFunctionContext) XblPresenceAddDevicePresenceChangedHandler(
     _In_ XblContextHandle xblContext,
     _In_ XblPresenceDevicePresenceChangedHandler* handler,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     if (xblContext == nullptr || handler == nullptr)
     {
@@ -436,22 +475,26 @@ STDAPI_(XblFunctionContext) XblPresenceAddDevicePresenceChangedHandler(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceRemoveDevicePresenceChangedHandler(
     _In_ XblContextHandle xblContext,
     _In_ XblFunctionContext token
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xblContext);
     xblContext->PresenceService()->RemoveDevicePresenceChangedHandler(token);
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI_(XblFunctionContext) XblPresenceAddTitlePresenceChangedHandler(
     _In_ XblContextHandle xblContext,
     _In_ XblPresenceTitlePresenceChangedHandler* handler,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     if (xblContext == nullptr || handler == nullptr)
     {
@@ -475,16 +518,19 @@ STDAPI_(XblFunctionContext) XblPresenceAddTitlePresenceChangedHandler(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceRemoveTitlePresenceChangedHandler(
     _In_ XblContextHandle xblContext,
     _In_ XblFunctionContext token
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xblContext);
     xblContext->PresenceService()->RemoveTitlePresenceChangedHandler(token);
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceTrackUsers(
     _In_ XblContextHandle xblContext,
@@ -503,27 +549,33 @@ STDAPI XblPresenceStopTrackingUsers(
     _In_ const uint64_t* xuids,
     _In_ size_t xuidsCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContext == nullptr || xuids == nullptr);
     return xblContext->PresenceService()->StopTrackingUsers(Vector<uint64_t>(xuids, xuids + xuidsCount));
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceTrackAdditionalTitles(
     _In_ XblContextHandle xblContext,
     _In_ const uint32_t* titleIds,
     _In_ size_t titleIdsCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContext == nullptr || titleIds == nullptr);
     return xblContext->PresenceService()->TrackAdditionalTitles(Vector<uint32_t>(titleIds, titleIds + titleIdsCount));
 }
+CATCH_RETURN()
 
 STDAPI XblPresenceStopTrackingAdditionalTitles(
     _In_ XblContextHandle xblContext,
     _In_ const uint32_t* titleIds,
     _In_ size_t titleIdsCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xblContext == nullptr || titleIds == nullptr);
     return xblContext->PresenceService()->StopTrackingAdditionalTitles(Vector<uint32_t>(titleIds, titleIds + titleIdsCount));
-}
\ No newline at end of file
+}
+CATCH_RETURN()
\ No newline at end of file
diff --git a/Source/Services/Privacy/privacy_api.cpp b/Source/Services/Privacy/privacy_api.cpp
index c91d4d5e..ea4386dd 100644
--- a/Source/Services/Privacy/privacy_api.cpp
+++ b/Source/Services/Privacy/privacy_api.cpp
@@ -12,6 +12,7 @@ STDAPI XblPrivacyGetAvoidListAsync(
     _In_ XblContextHandle xblContextHandle,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xblContextHandle);
 
@@ -56,11 +57,13 @@ STDAPI XblPrivacyGetAvoidListAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblPrivacyGetAvoidListResultCount(
     _In_ XAsyncBlock* async,
     _Out_ size_t* xuidCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(async == nullptr || xuidCount == nullptr);
 
@@ -70,21 +73,25 @@ STDAPI XblPrivacyGetAvoidListResultCount(
 
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblPrivacyGetAvoidListResult(
     _In_ XAsyncBlock* async,
     _In_ size_t xuidCount,
     _Out_writes_(xuidCount) uint64_t* xuids
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_IF(xuidCount == 0, S_OK);
     return XAsyncGetResult(async, nullptr, xuidCount * sizeof(uint64_t), xuids, nullptr);
 }
+CATCH_RETURN()
 
 HRESULT CopyPermissionCheckResult(
     const PermissionCheckResult& result,
     void* buffer
 ) noexcept
+try
 {
     auto resultPtr = static_cast<XblPermissionCheckResult*>(buffer);
     auto reasonsPtr = reinterpret_cast<XblPermissionDenyReasonDetails*>(resultPtr + 1);
@@ -102,6 +109,7 @@ HRESULT CopyPermissionCheckResult(
 
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblPrivacyCheckPermissionAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -109,6 +117,7 @@ STDAPI XblPrivacyCheckPermissionAsync(
     _In_ uint64_t targetXuid,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xblContextHandle);
 
@@ -153,14 +162,17 @@ STDAPI XblPrivacyCheckPermissionAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblPrivacyCheckPermissionResultSize(
     _In_ XAsyncBlock* async,
     _Out_ size_t* resultSizeInBytes
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResultSize(async, resultSizeInBytes);
 }
+CATCH_RETURN()
 
 STDAPI XblPrivacyCheckPermissionResult(
     _In_ XAsyncBlock* async,
@@ -169,6 +181,7 @@ STDAPI XblPrivacyCheckPermissionResult(
     _Outptr_ XblPermissionCheckResult** result,
     _Out_opt_ size_t* bufferUsed
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(result);
     auto hr = XAsyncGetResult(async, nullptr, bufferSize, buffer, bufferUsed);
@@ -178,6 +191,7 @@ STDAPI XblPrivacyCheckPermissionResult(
     }
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblPrivacyCheckPermissionForAnonymousUserAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -185,6 +199,7 @@ STDAPI XblPrivacyCheckPermissionForAnonymousUserAsync(
     _In_ XblAnonymousUserType userType,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xblContextHandle);
 
@@ -229,14 +244,17 @@ STDAPI XblPrivacyCheckPermissionForAnonymousUserAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblPrivacyCheckPermissionForAnonymousUserResultSize(
     _In_ XAsyncBlock* async,
     _Out_ size_t* resultSizeInBytes
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResultSize(async, resultSizeInBytes);
 }
+CATCH_RETURN()
 
 STDAPI XblPrivacyCheckPermissionForAnonymousUserResult(
     _In_ XAsyncBlock* async,
@@ -245,9 +263,11 @@ STDAPI XblPrivacyCheckPermissionForAnonymousUserResult(
     _Outptr_ XblPermissionCheckResult** result,
     _Out_opt_ size_t* bufferUsed
 ) XBL_NOEXCEPT
+try
 {
     return XblPrivacyCheckPermissionResult(async, bufferSize, buffer, result, bufferUsed);
 }
+CATCH_RETURN()
 
 STDAPI XblPrivacyBatchCheckPermissionAsync(
     _In_ XblContextHandle xblContextHandle,
@@ -259,6 +279,7 @@ STDAPI XblPrivacyBatchCheckPermissionAsync(
     _In_ size_t userTypesCount,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xblContextHandle);
     RETURN_HR_INVALIDARGUMENT_IF(permissionsToCheck == nullptr || permissionsCount == 0);
@@ -333,14 +354,17 @@ STDAPI XblPrivacyBatchCheckPermissionAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblPrivacyBatchCheckPermissionResultSize(
     _In_ XAsyncBlock* async,
     _Out_ size_t* resultSizeInBytes
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResultSize(async, resultSizeInBytes);
 }
+CATCH_RETURN()
 
 STDAPI XblPrivacyBatchCheckPermissionResult(
     _In_ XAsyncBlock* async,
@@ -350,6 +374,7 @@ STDAPI XblPrivacyBatchCheckPermissionResult(
     _Out_ size_t* resultsCount,
     _Out_opt_ size_t* bufferUsed
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(results == nullptr || resultsCount == nullptr);
 
@@ -378,11 +403,13 @@ STDAPI XblPrivacyBatchCheckPermissionResult(
     }
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblPrivacyGetMuteListAsync(
     _In_ XblContextHandle xblContextHandle,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xblContextHandle);
 
@@ -427,11 +454,13 @@ STDAPI XblPrivacyGetMuteListAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblPrivacyGetMuteListResultCount(
     _In_ XAsyncBlock* async,
     _Out_ size_t* xuidCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(async == nullptr || xuidCount == nullptr);
 
@@ -441,13 +470,16 @@ STDAPI XblPrivacyGetMuteListResultCount(
 
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblPrivacyGetMuteListResult(
     _In_ XAsyncBlock* async,
     _In_ size_t xuidCount,
     _Out_writes_(xuidCount) uint64_t* xuids
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_IF(xuidCount == 0, S_OK);
     return XAsyncGetResult(async, nullptr, xuidCount * sizeof(uint64_t), xuids, nullptr);
-}
\ No newline at end of file
+}
+CATCH_RETURN()
\ No newline at end of file
diff --git a/Source/Services/RealTimeActivityManager/real_time_activity_api.cpp b/Source/Services/RealTimeActivityManager/real_time_activity_api.cpp
index 4644c1e0..9cd6d624 100644
--- a/Source/Services/RealTimeActivityManager/real_time_activity_api.cpp
+++ b/Source/Services/RealTimeActivityManager/real_time_activity_api.cpp
@@ -12,25 +12,30 @@ STDAPI XblRealTimeActivitySubscriptionGetState(
     _In_ XblRealTimeActivitySubscriptionHandle subscriptionHandle,
     _Out_ XblRealTimeActivitySubscriptionState* state
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(subscriptionHandle == nullptr || state == nullptr);
     *state = subscriptionHandle->state;
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblRealTimeActivitySubscriptionGetId(
     _In_ XblRealTimeActivitySubscriptionHandle subscriptionHandle,
     _Out_ uint32_t* id
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(subscriptionHandle == nullptr || id == nullptr);
     *id = subscriptionHandle->id;
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblRealTimeActivityActivate(
     _In_ XblContextHandle xboxLiveContext
 ) XBL_NOEXCEPT
+try
 {
     LOGS_DEBUG << __FUNCTION__;
     if (auto state{ GlobalState::Get() })
@@ -39,10 +44,12 @@ STDAPI XblRealTimeActivityActivate(
     }
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblRealTimeActivityDeactivate(
     _In_ XblContextHandle xboxLiveContext
 ) XBL_NOEXCEPT
+try
 {
     LOGS_DEBUG << __FUNCTION__;
     if (auto state{ GlobalState::Get() })
@@ -51,12 +58,14 @@ STDAPI XblRealTimeActivityDeactivate(
     }
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI_(XblFunctionContext) XblRealTimeActivityAddConnectionStateChangeHandler(
     _In_ XblContextHandle xboxLiveContext,
     _In_ XblRealTimeActivityConnectionStateChangeHandler* handler,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     LOGS_DEBUG << __FUNCTION__;
     RETURN_HR_INVALIDARGUMENT_IF(xboxLiveContext == nullptr || handler == nullptr);
@@ -85,11 +94,13 @@ STDAPI_(XblFunctionContext) XblRealTimeActivityAddConnectionStateChangeHandler(
         return E_XBL_NOT_INITIALIZED;
     }
 }
+CATCH_RETURN()
 
 STDAPI XblRealTimeActivityRemoveConnectionStateChangeHandler(
     _In_ XblContextHandle xboxLiveContext,
     _In_ XblFunctionContext token
 ) XBL_NOEXCEPT
+try
 {
     LOGS_DEBUG << __FUNCTION__;
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xboxLiveContext);
@@ -104,12 +115,14 @@ STDAPI XblRealTimeActivityRemoveConnectionStateChangeHandler(
         return E_XBL_NOT_INITIALIZED;
     }
 }
+CATCH_RETURN()
 
 STDAPI_(XblFunctionContext) XblRealTimeActivityAddSubscriptionErrorHandler(
     _In_ XblContextHandle xboxLiveContext,
     _In_ XblRealTimeActivitySubscriptionErrorHandler* handler,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     LOGS_DEBUG << __FUNCTION__ << ": DEPRECATED, No action taken by XSAPI.";
     UNREFERENCED_PARAMETER(xboxLiveContext);
@@ -117,23 +130,27 @@ STDAPI_(XblFunctionContext) XblRealTimeActivityAddSubscriptionErrorHandler(
     UNREFERENCED_PARAMETER(context);
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblRealTimeActivityRemoveSubscriptionErrorHandler(
     _In_ XblContextHandle xboxLiveContext,
     _In_ XblFunctionContext token
 ) XBL_NOEXCEPT
+try
 {
     LOGS_DEBUG << __FUNCTION__ << ": DEPRECATED, No action taken by XSAPI.";
     UNREFERENCED_PARAMETER(xboxLiveContext);
     UNREFERENCED_PARAMETER(token);
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI_(XblFunctionContext) XblRealTimeActivityAddResyncHandler(
     _In_ XblContextHandle xboxLiveContext,
     _In_ XblRealTimeActivityResyncHandler* handler,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     LOGS_DEBUG << __FUNCTION__;
     RETURN_HR_INVALIDARGUMENT_IF(xboxLiveContext == nullptr || handler == nullptr);
@@ -161,11 +178,13 @@ STDAPI_(XblFunctionContext) XblRealTimeActivityAddResyncHandler(
         return E_XBL_NOT_INITIALIZED;
     }
 }
+CATCH_RETURN()
 
 STDAPI XblRealTimeActivityRemoveResyncHandler(
     _In_ XblContextHandle xboxLiveContext,
     _In_ XblFunctionContext token
 ) XBL_NOEXCEPT
+try
 {
     LOGS_DEBUG << __FUNCTION__;
     RETURN_HR_INVALIDARGUMENT_IF_NULL(xboxLiveContext);
@@ -180,3 +199,4 @@ STDAPI XblRealTimeActivityRemoveResyncHandler(
         return E_XBL_NOT_INITIALIZED;
     }
 }
+CATCH_RETURN()
diff --git a/Source/Services/Social/profile_api.cpp b/Source/Services/Social/profile_api.cpp
index 7ccac97f..66f09353 100644
--- a/Source/Services/Social/profile_api.cpp
+++ b/Source/Services/Social/profile_api.cpp
@@ -146,6 +146,7 @@ STDAPI XblProfileGetUserProfilesResultCount(
     _In_ XAsyncBlock* async,
     _Out_ size_t* profileCount
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(async == nullptr || profileCount == nullptr);
 
@@ -158,20 +159,24 @@ STDAPI XblProfileGetUserProfilesResultCount(
     }
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblProfileGetUserProfileResult(
     _In_ XAsyncBlock* async,
     _Out_ XblUserProfile* profile
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResult(async, nullptr, sizeof(XblUserProfile), profile, nullptr);
 }
+CATCH_RETURN()
 
 STDAPI XblProfileGetUserProfilesResult(
     _In_ XAsyncBlock* async,
     _In_ size_t profilesCount,
     _Out_writes_(profilesCount) XblUserProfile* profiles
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_IF(profilesCount == 0, S_OK);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(async);
@@ -186,20 +191,25 @@ STDAPI XblProfileGetUserProfilesResult(
     hr = XAsyncGetResult(async, nullptr, profilesCount * sizeof(XblUserProfile), profiles, nullptr);
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblProfileGetUserProfilesForSocialGroupResultCount(
     _In_ XAsyncBlock* async,
     _Out_ size_t* profileCount
 ) XBL_NOEXCEPT
+try
 {
     return XblProfileGetUserProfilesResultCount(async, profileCount);
 }
+CATCH_RETURN()
 
 STDAPI XblProfileGetUserProfilesForSocialGroupResult(
     _In_ XAsyncBlock* async,
     _In_ size_t profilesCount,
     _Out_writes_(profilesCount) XblUserProfile* profiles
 ) XBL_NOEXCEPT
+try
 {
     return XblProfileGetUserProfilesResult(async, profilesCount, profiles);
 }
+CATCH_RETURN()
diff --git a/Source/Services/StringVerify/string_service.cpp b/Source/Services/StringVerify/string_service.cpp
index 1517d41f..061721a5 100644
--- a/Source/Services/StringVerify/string_service.cpp
+++ b/Source/Services/StringVerify/string_service.cpp
@@ -77,19 +77,23 @@ STDAPI XblStringVerifyStringAsync(
     _In_ const char* stringToVerify,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(xboxLiveContextHandle == nullptr || stringToVerify == nullptr || async == nullptr);
 
     return XblStringVerifyStringsAsync(xboxLiveContextHandle, &stringToVerify, 1, async);
 }
+CATCH_RETURN()
 
 STDAPI XblStringVerifyStringResultSize(
     _In_ XAsyncBlock* asyncBlock,
     _Out_ size_t* resultSizeInBytes
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResultSize(asyncBlock, resultSizeInBytes);
 }
+CATCH_RETURN()
 
 STDAPI XblStringVerifyStringResult(
     _In_ XAsyncBlock* asyncBlock,
@@ -98,6 +102,7 @@ STDAPI XblStringVerifyStringResult(
     _Outptr_ XblVerifyStringResult** ptrToBuffer,
     _Out_opt_ size_t* bufferUsed
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(ptrToBuffer);
     auto hr = XAsyncGetResult(asyncBlock, nullptr, bufferSize, buffer, bufferUsed);
@@ -107,6 +112,7 @@ STDAPI XblStringVerifyStringResult(
     }
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblStringVerifyStringsAsync(
     _In_ XblContextHandle xboxLiveContextHandle,
@@ -114,6 +120,7 @@ STDAPI XblStringVerifyStringsAsync(
     _In_ const uint64_t stringsCount,
     _In_ XAsyncBlock* async
 ) XBL_NOEXCEPT
+try
 {
     xsapi_internal_vector<xsapi_internal_string> strings;
     for (uint32_t i = 0; i < stringsCount; i++) {
@@ -214,14 +221,17 @@ STDAPI XblStringVerifyStringsAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblStringVerifyStringsResultSize(
     _In_ XAsyncBlock* asyncBlock,
     _Out_ size_t* resultSizeInBytes
 ) XBL_NOEXCEPT
+try
 {
     return XAsyncGetResultSize(asyncBlock, resultSizeInBytes);
 }
+CATCH_RETURN()
 
 STDAPI XblStringVerifyStringsResult(
     _In_ XAsyncBlock* asyncBlock,
@@ -231,6 +241,7 @@ STDAPI XblStringVerifyStringsResult(
     _Out_ size_t* stringsCount,
     _Out_opt_ size_t* bufferUsed
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(ptrToBuffer);
 
@@ -249,3 +260,4 @@ STDAPI XblStringVerifyStringsResult(
     }
     return hr;
 }
+CATCH_RETURN()
diff --git a/Source/Shared/build_version.h b/Source/Shared/build_version.h
index 549f80cb..1830b6d2 100644
--- a/Source/Shared/build_version.h
+++ b/Source/Shared/build_version.h
@@ -9,4 +9,4 @@
 //*********************************************************
 #pragma once
  
-#define XBOX_SERVICES_API_VERSION_STRING "2021.10.20220301.4"
+#define XBOX_SERVICES_API_VERSION_STRING "2021.10.20220503.5"
diff --git a/Source/Shared/fault_injection.cpp b/Source/Shared/fault_injection.cpp
index 6bbb4c71..64c2ac5d 100644
--- a/Source/Shared/fault_injection.cpp
+++ b/Source/Shared/fault_injection.cpp
@@ -8,6 +8,7 @@ static fault_injection g_faultInjection; // not hanging this off of global state
 #endif
 
 STDAPI_(void) XblEnableFaultInjection(_In_ uint64_t featureId) XBL_NOEXCEPT
+try
 {
 #if _DEBUG // fault injection only enabled on debug bits so as not to impact retail titles
     g_faultInjection.m_enabledFeatureMask |= featureId;
@@ -15,8 +16,10 @@ STDAPI_(void) XblEnableFaultInjection(_In_ uint64_t featureId) XBL_NOEXCEPT
     UNREFERENCED_PARAMETER(featureId);
 #endif
 }
+CATCH_RETURN_WITH(;)
 
-STDAPI_(uint64_t) XblGetFaultCounter()
+STDAPI_(uint64_t) XblGetFaultCounter() XBL_NOEXCEPT
+try
 {
 #if _DEBUG // testing feature only enabled on debug bits so as not to impact retail titles
     return g_faultInjection.m_failTotalCounter;
@@ -24,8 +27,10 @@ STDAPI_(uint64_t) XblGetFaultCounter()
     return 0;
 #endif
 }
+CATCH_RETURN_WITH(0)
 
-STDAPI_(void) XblSetFaultInjectOptions(int64_t failFreq, uint64_t freqChangeSpeed, int64_t freqChangeAmount)
+STDAPI_(void) XblSetFaultInjectOptions(int64_t failFreq, uint64_t freqChangeSpeed, int64_t freqChangeAmount) XBL_NOEXCEPT
+try
 {
 #if _DEBUG // testing feature only enabled on debug bits so as not to impact retail titles
     g_faultInjection.m_failFreq = failFreq;
@@ -37,8 +42,10 @@ STDAPI_(void) XblSetFaultInjectOptions(int64_t failFreq, uint64_t freqChangeSpee
     UNREFERENCED_PARAMETER(freqChangeAmount);
 #endif
 }
+CATCH_RETURN_WITH(;)
 
-STDAPI_(bool) XblShouldFaultInject(_In_ uint64_t featureId)
+STDAPI_(bool) XblShouldFaultInject(_In_ uint64_t featureId) XBL_NOEXCEPT
+try
 {
 #if _DEBUG // testing feature only enabled on debug bits so as not to impact retail titles
     if ((g_faultInjection.m_enabledFeatureMask & featureId) == featureId)
@@ -63,4 +70,5 @@ STDAPI_(bool) XblShouldFaultInject(_In_ uint64_t featureId)
 
     return false;
 }
+CATCH_RETURN()
 
diff --git a/Source/Shared/fault_injection.h b/Source/Shared/fault_injection.h
index 81459c42..8b271ed3 100644
--- a/Source/Shared/fault_injection.h
+++ b/Source/Shared/fault_injection.h
@@ -8,9 +8,9 @@
 extern "C"
 {
 STDAPI_(void) XblEnableFaultInjection(_In_ uint64_t featureId) XBL_NOEXCEPT;
-STDAPI_(bool) XblShouldFaultInject(_In_ uint64_t featureId);
-STDAPI_(uint64_t) XblGetFaultCounter();
-STDAPI_(void) XblSetFaultInjectOptions(int64_t failFreq, uint64_t freqChangeSpeed, int64_t freqChangeAmount);
+STDAPI_(bool) XblShouldFaultInject(_In_ uint64_t featureId) XBL_NOEXCEPT;
+STDAPI_(uint64_t) XblGetFaultCounter() XBL_NOEXCEPT;
+STDAPI_(void) XblSetFaultInjectOptions(int64_t failFreq, uint64_t freqChangeSpeed, int64_t freqChangeAmount) XBL_NOEXCEPT;
 }
 
 NAMESPACE_MICROSOFT_XBOX_SERVICES_CPP_BEGIN
diff --git a/Source/Shared/http_call_api.cpp b/Source/Shared/http_call_api.cpp
index 2137b669..336dbc0b 100644
--- a/Source/Shared/http_call_api.cpp
+++ b/Source/Shared/http_call_api.cpp
@@ -16,6 +16,7 @@ STDAPI XblHttpCallCreate(
     _In_z_ const char* url,
     _Out_ XblHttpCallHandle* call
 ) XBL_NOEXCEPT
+try
 {
     VERIFY_XBL_INITIALIZED();
 
@@ -31,12 +32,14 @@ STDAPI XblHttpCallCreate(
     }
     return hr;
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallPerformAsync(
     _In_ XblHttpCallHandle call,
     _In_ XblHttpCallResponseBodyType type,
     _Inout_ XAsyncBlock* asyncBlock
 ) XBL_NOEXCEPT
+try
 {
     UNREFERENCED_PARAMETER(type);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
@@ -72,11 +75,13 @@ STDAPI XblHttpCallPerformAsync(
         }
     });
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallDuplicateHandle(
     _In_ XblHttpCallHandle call,
     _Out_ XblHttpCallHandle* duplicatedHandle
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF(call == nullptr || duplicatedHandle == nullptr);
     call->AddRef();
@@ -84,10 +89,12 @@ STDAPI XblHttpCallDuplicateHandle(
 
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI_(void) XblHttpCallCloseHandle(
     _In_ XblHttpCallHandle call
 ) XBL_NOEXCEPT
+try
 {
     if (call)
     {
@@ -95,27 +102,32 @@ STDAPI_(void) XblHttpCallCloseHandle(
     }
     return;
 }
+CATCH_RETURN_WITH(;)
 
 STDAPI XblHttpCallSetTracing(
     _In_ XblHttpCallHandle call,
     _In_ bool traceCall
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
 
     return call->SetTracing(traceCall);
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallGetRequestUrl(
     _In_ XblHttpCallHandle call,
     _Out_ const char** url
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(url);
 
     return call->GetRequestUrl(url);
 }
+CATCH_RETURN()
 
 // HttpCallRequest Set APIs
 STDAPI XblHttpCallRequestSetRequestBodyBytes(
@@ -123,19 +135,23 @@ STDAPI XblHttpCallRequestSetRequestBodyBytes(
     _In_reads_bytes_(requestBodySize) const uint8_t* requestBodyBytes,
     _In_ uint32_t requestBodySize
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
     return call->SetRequestBody(requestBodyBytes, requestBodySize);
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallRequestSetRequestBodyString(
     _In_ XblHttpCallHandle call,
     _In_z_ const char* requestBodyString
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
     return call->SetRequestBody(requestBodyString);
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallRequestSetHeader(
     _In_ XblHttpCallHandle call,
@@ -143,6 +159,7 @@ STDAPI XblHttpCallRequestSetHeader(
     _In_z_ const char* headerValue,
     _In_ bool allowTracing
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(headerName);
@@ -152,21 +169,25 @@ STDAPI XblHttpCallRequestSetHeader(
 
     return call->SetHeader(headerNameString, headerValueString, allowTracing);
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallRequestSetRetryAllowed(
     _In_ XblHttpCallHandle call,
     _In_ bool retryAllowed
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
 
     return call->SetRetryAllowed(retryAllowed);
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallRequestSetRetryCacheId(
     _In_ XblHttpCallHandle call,
     _In_ uint32_t retryAfterCacheId
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
 
@@ -178,36 +199,43 @@ STDAPI XblHttpCallRequestSetRetryCacheId(
 
     return call->SetRetryCacheId(retryAfterCacheId);
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallRequestSetLongHttpCall(
     _In_ XblHttpCallHandle call,
     _In_ bool longHttpCall
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
 
     call->SetLongHttpCall(longHttpCall);
     return S_OK;
 }
+CATCH_RETURN()
 
 // HttpCallResponse Get APIs
 STDAPI XblHttpCallGetResponseString(
     _In_ XblHttpCallHandle call,
     _Out_ const char** responseString
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
     return call->GetResponseString(responseString);
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallGetResponseBodyBytesSize(
     _In_ XblHttpCallHandle call,
     _Out_ size_t* bufferSize
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
     return call->GetResponseBodyBytesSize(bufferSize);
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallGetResponseBodyBytes(
     _In_ XblHttpCallHandle call,
@@ -215,15 +243,18 @@ STDAPI XblHttpCallGetResponseBodyBytes(
     _Out_writes_bytes_to_(bufferSize, *bufferUsed) uint8_t* buffer,
     _Out_opt_ size_t* bufferUsed
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
     return call->GetResponseBodyBytes(bufferSize, buffer, bufferUsed);
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallGetStatusCode(
     _In_ XblHttpCallHandle call,
     _Out_ uint32_t* statusCode
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
     RETURN_HR_INVALIDARGUMENT_IF_NULL(statusCode);
@@ -231,44 +262,53 @@ STDAPI XblHttpCallGetStatusCode(
     *statusCode = call->HttpStatus();
     return S_OK;
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallGetNetworkErrorCode(
     _In_ XblHttpCallHandle call,
     _Out_ HRESULT* networkErrorCode,
     _Out_ uint32_t* platformNetworkErrorCode
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
     return call->GetNetworkErrorCode(networkErrorCode, platformNetworkErrorCode);
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallGetPlatformNetworkErrorMessage(
     _In_ XblHttpCallHandle call,
     _Out_ const char** platformNetworkErrorMessage
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
     return call->GetPlatformNetworkErrorMessage(platformNetworkErrorMessage);
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallGetHeader(
     _In_ XblHttpCallHandle call,
     _In_z_ const char* headerName,
     _Out_ const char** headerValue
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
     return call->ResponseGetHeader(headerName, headerValue);
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallGetNumHeaders(
     _In_ XblHttpCallHandle call,
     _Out_ uint32_t* numHeaders
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
     return call->ResponseGetNumHeaders(numHeaders);
 }
+CATCH_RETURN()
 
 STDAPI XblHttpCallGetHeaderAtIndex(
     _In_ XblHttpCallHandle call,
@@ -276,7 +316,9 @@ STDAPI XblHttpCallGetHeaderAtIndex(
     _Out_ const char** headerName,
     _Out_ const char** headerValue
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(call);
     return call->ResponseGetHeaderAtIndex(headerIndex, headerName, headerValue);
 }
+CATCH_RETURN()
diff --git a/Source/System/platform_api.cpp b/Source/System/platform_api.cpp
index 663fb124..ff63f4f5 100644
--- a/Source/System/platform_api.cpp
+++ b/Source/System/platform_api.cpp
@@ -10,12 +10,14 @@ STDAPI XblLocalStorageWriteComplete(
     _In_ XblClientOperationResult result,
     _In_ size_t dataSize
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(operation);
 
     auto writeOp{ static_cast<LocalStorage::WriteOperation*>(operation) };
     return writeOp->Complete({ dataSize, XblClientOperation::HresultFromResult(result) });
 }
+CATCH_RETURN()
 
 STDAPI XblLocalStorageReadComplete(
     _In_ XblClientOperationHandle operation,
@@ -23,6 +25,7 @@ STDAPI XblLocalStorageReadComplete(
     _In_ size_t dataSize,
     _In_reads_bytes_opt_(dataSize) void const* data
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(operation);
     RETURN_HR_INVALIDARGUMENT_IF(dataSize && !data);
@@ -34,17 +37,20 @@ STDAPI XblLocalStorageReadComplete(
 
     return readOp->Complete(Result<Vector<uint8_t>>{ std::move(dataVector), XblClientOperation::HresultFromResult(result) });
 }
+CATCH_RETURN()
 
 STDAPI XblLocalStorageClearComplete(
     _In_ XblClientOperationHandle operation,
     _In_ XblClientOperationResult result
 ) XBL_NOEXCEPT
+try
 {
     RETURN_HR_INVALIDARGUMENT_IF_NULL(operation);
 
     auto clearOp{ static_cast<LocalStorage::ClearOperation*>(operation) };
     return clearOp->Complete(XblClientOperation::HresultFromResult(result));
 }
+CATCH_RETURN()
 
 STDAPI XblLocalStorageSetHandlers(
     _In_opt_ XTaskQueueHandle queue,
@@ -53,6 +59,7 @@ STDAPI XblLocalStorageSetHandlers(
     _In_ XblLocalStorageClearHandler clearHandler,
     _In_opt_ void* context
 ) XBL_NOEXCEPT
+try
 {
     if (GlobalState::Get())
     {
@@ -75,4 +82,5 @@ STDAPI XblLocalStorageSetHandlers(
     }
 
     return S_OK;
-}
\ No newline at end of file
+}
+CATCH_RETURN()