10 files changed, 207 insertions, 64 deletions

diff --git a/src/burn/engine/apply.cpp b/src/burn/engine/apply.cpp
index 048cd98b..d215cfe5 100644
--- a/src/burn/engine/apply.cpp
+++ b/src/burn/engine/apply.cpp
@@ -110,7 +110,8 @@ static HRESULT ApplyLayoutContainer(
 static HRESULT ApplyProcessPayload(
     __in BURN_CACHE_CONTEXT* pContext,
     __in_opt BURN_PACKAGE* pPackage,
-    __in BURN_PAYLOAD_GROUP_ITEM* pPayloadGroupItem
+    __in BURN_PAYLOAD_GROUP_ITEM* pPayloadGroupItem,
+    __in BOOL fVital
     );
 static HRESULT ApplyCacheVerifyContainerOrPayload(
     __in BURN_CACHE_CONTEXT* pContext,
@@ -203,6 +204,10 @@ static HRESULT DoRollbackActions(
     __in DWORD dwCheckpoint,
     __out BOOTSTRAPPER_APPLY_RESTART* pRestart
     );
+static BOOL ShouldSkipPackage(
+    __in BURN_PACKAGE* pPackage,
+    __in BOOL fRollback
+    );
 static HRESULT ExecuteRelatedBundle(
     __in BURN_ENGINE_STATE* pEngineState,
     __in BURN_EXECUTE_ACTION* pExecuteAction,
@@ -379,6 +384,7 @@ extern "C" void ApplyReset(
     {
         BURN_PACKAGE* pPackage = pPackages->rgPackages + i;
         pPackage->hrCacheResult = S_OK;
+        pPackage->fAcquireOptionalSource = FALSE;
         pPackage->fReachedExecution = FALSE;
         pPackage->fAbandonedProcess = FALSE;
         pPackage->transactionRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN;
@@ -633,7 +639,7 @@ extern "C" HRESULT ApplyCache(
             break;
 
         case BURN_CACHE_ACTION_TYPE_SIGNAL_SYNCPOINT:
-            if (!::SetEvent(pCacheAction->syncpoint.hEvent))
+            if (!::SetEvent(pCacheAction->syncpoint.pPackage->hCacheEvent))
             {
                 ExitWithLastError(hr, "Failed to set syncpoint event.");
             }
@@ -959,12 +965,13 @@ static HRESULT ApplyCachePackage(
     HRESULT hr = S_OK;
     BOOL fCanceledBegin = FALSE;
     BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION cachePackageCompleteAction = BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION_NONE;
+    BOOL fVital = pPackage->fCacheVital;
 
     for (;;)
     {
         fCanceledBegin = FALSE;
 
-        hr = UserExperienceOnCachePackageBegin(pContext->pUX, pPackage->sczId, pPackage->payloads.cItems, pPackage->payloads.qwTotalSize);
+        hr = UserExperienceOnCachePackageBegin(pContext->pUX, pPackage->sczId, pPackage->payloads.cItems, pPackage->payloads.qwTotalSize, fVital);
         if (FAILED(hr))
         {
             fCanceledBegin = TRUE;
@@ -975,7 +982,7 @@ static HRESULT ApplyCachePackage(
             {
                 BURN_PAYLOAD_GROUP_ITEM* pPayloadGroupItem = pPackage->payloads.rgItems + i;
 
-                hr = ApplyProcessPayload(pContext, pPackage, pPayloadGroupItem);
+                hr = ApplyProcessPayload(pContext, pPackage, pPayloadGroupItem, fVital);
                 if (FAILED(hr))
                 {
                     break;
@@ -984,7 +991,7 @@ static HRESULT ApplyCachePackage(
         }
 
         pPackage->hrCacheResult = hr;
-        cachePackageCompleteAction = SUCCEEDED(hr) || pPackage->fVital || fCanceledBegin ? BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION_NONE : BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION_IGNORE;
+        cachePackageCompleteAction = SUCCEEDED(hr) || (pPackage->fVital && fVital) || fCanceledBegin ? BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION_NONE : BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION_IGNORE;
         UserExperienceOnCachePackageComplete(pContext->pUX, pPackage->sczId, hr, &cachePackageCompleteAction);
 
         if (SUCCEEDED(hr))
@@ -1014,7 +1021,7 @@ static HRESULT ApplyCachePackage(
 
             continue;
         }
-        else if (BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION_IGNORE == cachePackageCompleteAction && !pPackage->fVital) // ignore non-vital download failures.
+        else if (BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION_IGNORE == cachePackageCompleteAction && (!pPackage->fVital || !fVital)) // ignore non-vital download failures.
         {
             LogId(REPORT_STANDARD, MSG_CACHE_CONTINUING_NONVITAL_PACKAGE, pPackage->sczId, hr);
             hr = S_OK;
@@ -1101,7 +1108,7 @@ static HRESULT ApplyLayoutBundle(
     {
         BURN_PAYLOAD_GROUP_ITEM* pPayloadGroupItem = pPayloads->rgItems + i;
 
-        hr = ApplyProcessPayload(pContext, NULL, pPayloadGroupItem);
+        hr = ApplyProcessPayload(pContext, NULL, pPayloadGroupItem, TRUE);
         ExitOnFailure(hr, "Failed to layout bundle payload: %ls", pPayloadGroupItem->pPayload->sczKey);
     }
 
@@ -1164,12 +1171,14 @@ LExit:
 static HRESULT ApplyProcessPayload(
     __in BURN_CACHE_CONTEXT* pContext,
     __in_opt BURN_PACKAGE* pPackage,
-    __in BURN_PAYLOAD_GROUP_ITEM* pPayloadGroupItem
+    __in BURN_PAYLOAD_GROUP_ITEM* pPayloadGroupItem,
+    __in BOOL fVital
     )
 {
     HRESULT hr = S_OK;
     DWORD cTryAgainAttempts = 0;
     BOOL fRetry = FALSE;
+    BOOTSTRAPPER_CACHEPACKAGENONVITALVALIDATIONFAILURE_ACTION action = BOOTSTRAPPER_CACHEPACKAGENONVITALVALIDATIONFAILURE_ACTION_NONE;
     BURN_PAYLOAD* pPayload = pPayloadGroupItem->pPayload;
 
     Assert(pContext->pPayloads && pPackage || pContext->wzLayoutDirectory);
@@ -1184,6 +1193,18 @@ static HRESULT ApplyProcessPayload(
     {
         ExitFunction();
     }
+    else if (pPackage && !pPackage->fAcquireOptionalSource && !fVital)
+    {
+        HRESULT hrResponse = UserExperienceOnCachePackageNonVitalValidationFailure(pContext->pUX, pPackage->sczId, hr, &action);
+        ExitOnRootFailure(hrResponse, "BA aborted cache package non-vital failure.");
+
+        if (BOOTSTRAPPER_CACHEPACKAGENONVITALVALIDATIONFAILURE_ACTION_ACQUIRE != action)
+        {
+            ExitFunction();
+        }
+
+        pPackage->fAcquireOptionalSource = TRUE;
+    }
 
     for (;;)
     {
@@ -2567,10 +2588,20 @@ static BOOL ShouldSkipPackage(
     )
 {
     BOOL fSkip = FALSE;
+    BURN_CACHE_PACKAGE_TYPE cachePackageType = fRollback ? pPackage->rollbackCacheType : pPackage->executeCacheType;
+    BOOL fCacheVital = BURN_CACHE_PACKAGE_TYPE_REQUIRED == cachePackageType;
 
-    if (FAILED(pPackage->hrCacheResult))
+    if (fCacheVital && FAILED(pPackage->hrCacheResult))
     {
-        LogId(REPORT_STANDARD, MSG_APPLY_SKIPPED_FAILED_CACHED_PACKAGE, pPackage->sczId, pPackage->hrCacheResult);
+        if (fRollback)
+        {
+            LogId(REPORT_STANDARD, MSG_APPLY_SKIPPED_ROLLBACK_NO_CACHE, pPackage->sczId, pPackage->hrCacheResult, LoggingActionStateToString(pPackage->rollback));
+        }
+        else
+        {
+            LogId(REPORT_STANDARD, MSG_APPLY_SKIPPED_FAILED_CACHED_PACKAGE, pPackage->sczId, pPackage->hrCacheResult);
+        }
+
         ExitFunction1(fSkip = TRUE);
     }
     else if (fRollback && pPackage->fAbandonedProcess)
diff --git a/src/burn/engine/core.cpp b/src/burn/engine/core.cpp
index 8dfa0010..c1e3a12c 100644
--- a/src/burn/engine/core.cpp
+++ b/src/burn/engine/core.cpp
@@ -2329,7 +2329,7 @@ static void LogPackages(
                 LogRollbackBoundary(pPackage->pRollbackBoundaryBackward);
             }
 
-            LogId(REPORT_STANDARD, MSG_PLANNED_PACKAGE, pPackage->sczId, LoggingPackageStateToString(pPackage->currentState), LoggingRequestStateToString(pPackage->defaultRequested), LoggingRequestStateToString(pPackage->requested), LoggingActionStateToString(pPackage->execute), LoggingActionStateToString(pPackage->rollback), LoggingCacheTypeToString(pPackage->authoredCacheType), LoggingCacheTypeToString(pPackage->cacheType), LoggingBoolToString(pPackage->fPlannedCache), LoggingBoolToString(pPackage->fPlannedUncache), LoggingDependencyActionToString(pPackage->dependencyExecute), LoggingPackageRegistrationStateToString(pPackage->fCanAffectRegistration, pPackage->expectedInstallRegistrationState), LoggingPackageRegistrationStateToString(pPackage->fCanAffectRegistration, pPackage->expectedCacheRegistrationState));
+            LogId(REPORT_STANDARD, MSG_PLANNED_PACKAGE, pPackage->sczId, LoggingPackageStateToString(pPackage->currentState), LoggingRequestStateToString(pPackage->defaultRequested), LoggingRequestStateToString(pPackage->requested), LoggingActionStateToString(pPackage->execute), LoggingActionStateToString(pPackage->rollback), LoggingCacheTypeToString(pPackage->authoredCacheType), LoggingCacheTypeToString(pPackage->cacheType), LoggingPlannedCacheToString(pPackage), LoggingBoolToString(pPackage->fPlannedUncache), LoggingDependencyActionToString(pPackage->dependencyExecute), LoggingPackageRegistrationStateToString(pPackage->fCanAffectRegistration, pPackage->expectedInstallRegistrationState), LoggingPackageRegistrationStateToString(pPackage->fCanAffectRegistration, pPackage->expectedCacheRegistrationState));
 
             if (BURN_PACKAGE_TYPE_MSI == pPackage->type)
             {
diff --git a/src/burn/engine/engine.mc b/src/burn/engine/engine.mc
index 52524edb..f5e3ca27 100644
--- a/src/burn/engine/engine.mc
+++ b/src/burn/engine/engine.mc
@@ -417,9 +417,9 @@ Planned related bundle: %1!ls!, detect type: %2!hs!, default plan type: %3!hs!,
 
 MessageId=208
 Severity=Warning
-SymbolicName=MSG_PLAN_DISABLING_ROLLBACK_NO_CACHE
+SymbolicName=MSG_APPLY_SKIPPED_ROLLBACK_NO_CACHE
 Language=English
-Plan disabled rollback due to incomplete cache for package: %1!ls!, original rollback action: %2!hs!
+Skipping apply rollback of package: %1!ls! due to cache error: 0x%2!x!, original rollback action: %3!hs!. Continuing...
 .
 
 MessageId=209
diff --git a/src/burn/engine/logging.cpp b/src/burn/engine/logging.cpp
index 77f5079c..1020d01f 100644
--- a/src/burn/engine/logging.cpp
+++ b/src/burn/engine/logging.cpp
@@ -445,6 +445,23 @@ extern "C" LPCSTR LoggingCacheTypeToString(
     }
 }
 
+extern "C" LPCSTR LoggingCachePackageTypeToString(
+    BURN_CACHE_PACKAGE_TYPE cachePackageType
+    )
+{
+    switch (cachePackageType)
+    {
+    case BURN_CACHE_PACKAGE_TYPE_NONE:
+        return "None";
+    case BURN_CACHE_PACKAGE_TYPE_OPTIONAL:
+        return "Optional";
+    case BURN_CACHE_PACKAGE_TYPE_REQUIRED:
+        return "Required";
+    default:
+        return "Invalid";
+    }
+}
+
 extern "C" LPCSTR LoggingDependencyActionToString(
     BURN_DEPENDENCY_ACTION action
     )
@@ -669,6 +686,18 @@ extern "C" LPCSTR LoggingPerMachineToString(
     return "PerUser";
 }
 
+extern "C" LPCSTR LoggingPlannedCacheToString(
+    __in const BURN_PACKAGE* pPackage
+    )
+{
+    if (!pPackage->hCacheEvent)
+    {
+        return "No";
+    }
+
+    return pPackage->fCacheVital ? "Vital" : "NonVital";
+}
+
 extern "C" LPCSTR LoggingRegistrationTypeToString(
     __in BOOTSTRAPPER_REGISTRATION_TYPE registrationType
     )
diff --git a/src/burn/engine/logging.h b/src/burn/engine/logging.h
index 857394b9..000b04f8 100644
--- a/src/burn/engine/logging.h
+++ b/src/burn/engine/logging.h
@@ -92,6 +92,10 @@ LPCSTR LoggingCacheTypeToString(
     BOOTSTRAPPER_CACHE_TYPE cacheType
     );
 
+LPCSTR LoggingCachePackageTypeToString(
+    BURN_CACHE_PACKAGE_TYPE cachePackageType
+    );
+
 LPCSTR LoggingDependencyActionToString(
     BURN_DEPENDENCY_ACTION action
     );
@@ -142,6 +146,10 @@ LPCSTR LoggingPerMachineToString(
     __in BOOL fPerMachine
     );
 
+LPCSTR LoggingPlannedCacheToString(
+    __in const BURN_PACKAGE* pPackage
+    );
+
 LPCSTR LoggingRegistrationTypeToString(
     __in BOOTSTRAPPER_REGISTRATION_TYPE registrationType
     );
diff --git a/src/burn/engine/package.h b/src/burn/engine/package.h
index 85f34de5..5fccf50a 100644
--- a/src/burn/engine/package.h
+++ b/src/burn/engine/package.h
@@ -16,6 +16,13 @@ typedef _BURN_PACKAGE BURN_PACKAGE;
 
 const DWORD BURN_PACKAGE_INVALID_PATCH_INDEX = 0x80000000;
 
+enum BURN_CACHE_PACKAGE_TYPE
+{
+    BURN_CACHE_PACKAGE_TYPE_NONE,
+    BURN_CACHE_PACKAGE_TYPE_OPTIONAL,
+    BURN_CACHE_PACKAGE_TYPE_REQUIRED,
+};
+
 enum BURN_EXE_DETECTION_TYPE
 {
     BURN_EXE_DETECTION_TYPE_NONE,
@@ -277,7 +284,7 @@ typedef struct _BURN_PACKAGE
     BOOTSTRAPPER_CACHE_TYPE cacheType;          // only valid during Plan.
     BOOTSTRAPPER_REQUEST_STATE defaultRequested;// only valid during Plan.
     BOOTSTRAPPER_REQUEST_STATE requested;       // only valid during Plan.
-    BOOL fPlannedCache;                         // only valid during Plan.
+    BOOL fCacheVital;                           // only valid during Plan.
     BOOL fPlannedUncache;                       // only valid during Plan.
     BOOTSTRAPPER_ACTION_STATE execute;          // only valid during Plan.
     BOOTSTRAPPER_ACTION_STATE rollback;         // only valid during Plan.
@@ -286,9 +293,12 @@ typedef struct _BURN_PACKAGE
     BURN_DEPENDENCY_ACTION dependencyExecute;   // only valid during Plan.
     BURN_DEPENDENCY_ACTION dependencyRollback;  // only valid during Plan.
     BOOL fDependencyManagerWasHere;             // only valid during Plan.
+    BURN_CACHE_PACKAGE_TYPE executeCacheType;   // only valid during Plan.
+    BURN_CACHE_PACKAGE_TYPE rollbackCacheType;  // only valid during Plan.
     HANDLE hCacheEvent;                         // only valid during Plan.
     LPWSTR sczCacheFolder;                      // only valid during Apply.
     HRESULT hrCacheResult;                      // only valid during Apply.
+    BOOL fAcquireOptionalSource;                // only valid during Apply.
     BOOL fReachedExecution;                     // only valid during Apply.
     BOOL fAbandonedProcess;                     // only valid during Apply.
 
diff --git a/src/burn/engine/plan.cpp b/src/burn/engine/plan.cpp
index 419d3272..18f9b274 100644
--- a/src/burn/engine/plan.cpp
+++ b/src/burn/engine/plan.cpp
@@ -78,11 +78,13 @@ static HRESULT AddRegistrationAction(
     );
 static HRESULT AddCachePackage(
     __in BURN_PLAN* pPlan,
-    __in BURN_PACKAGE* pPackage
+    __in BURN_PACKAGE* pPackage,
+    __in BOOL fVital
     );
 static HRESULT AddCachePackageHelper(
     __in BURN_PLAN* pPlan,
-    __in BURN_PACKAGE* pPackage
+    __in BURN_PACKAGE* pPackage,
+    __in BOOL fVital
     );
 static HRESULT AddCacheSlipstreamMsps(
     __in BURN_PLAN* pPlan,
@@ -134,7 +136,7 @@ static HRESULT CalculateExecuteActions(
     __in BURN_PACKAGE* pPackage,
     __in_opt BURN_ROLLBACK_BOUNDARY* pActiveRollbackBoundary
     );
-static BOOL NeedsCache(
+static BURN_CACHE_PACKAGE_TYPE GetCachePackageType(
     __in BURN_PACKAGE* pPackage,
     __in BOOL fExecute
     );
@@ -894,7 +896,7 @@ static HRESULT PlanPackagesHelper(
         DWORD iPackage = fReverseOrder ? cPackages - 1 - i : i;
         BURN_PACKAGE* pPackage = rgPackages + iPackage;
 
-        UserExperienceOnPlannedPackage(pUX, pPackage->sczId, pPackage->execute, pPackage->rollback, pPackage->fPlannedCache, pPackage->fPlannedUncache);
+        UserExperienceOnPlannedPackage(pUX, pPackage->sczId, pPackage->execute, pPackage->rollback, NULL != pPackage->hCacheEvent, pPackage->fPlannedUncache);
 
         if (pPackage->compatiblePackage.fPlannable)
         {
@@ -999,7 +1001,7 @@ static HRESULT ProcessPackage(
     {
         if (BOOTSTRAPPER_REQUEST_STATE_NONE != pPackage->requested)
         {
-            hr = PlanLayoutPackage(pPlan, pPackage);
+            hr = PlanLayoutPackage(pPlan, pPackage, TRUE);
             ExitOnFailure(hr, "Failed to plan layout package.");
         }
     }
@@ -1015,7 +1017,7 @@ static HRESULT ProcessPackage(
         {
             if (ForceCache(pPlan, pPackage))
             {
-                hr = AddCachePackage(pPlan, pPackage);
+                hr = AddCachePackage(pPlan, pPackage, TRUE);
                 ExitOnFailure(hr, "Failed to plan cache package.");
 
                 if (pPackage->fPerMachine)
@@ -1127,7 +1129,8 @@ LExit:
 
 extern "C" HRESULT PlanLayoutPackage(
     __in BURN_PLAN* pPlan,
-    __in BURN_PACKAGE* pPackage
+    __in BURN_PACKAGE* pPackage,
+    __in BOOL fVital
     )
 {
     HRESULT hr = S_OK;
@@ -1143,6 +1146,7 @@ extern "C" HRESULT PlanLayoutPackage(
 
     pCacheAction->type = BURN_CACHE_ACTION_TYPE_PACKAGE;
     pCacheAction->package.pPackage = pPackage;
+    pPackage->fCacheVital = fVital;
 
     ++pPlan->cOverallProgressTicksTotal;
 
@@ -1170,18 +1174,14 @@ extern "C" HRESULT PlanExecutePackage(
     hr = DependencyPlanPackageBegin(fPerMachine, pPackage, pPlan);
     ExitOnFailure(hr, "Failed to begin plan dependency actions for package: %ls", pPackage->sczId);
 
-    if (fRequestedCache || NeedsCache(pPackage, TRUE))
+    pPackage->executeCacheType = fRequestedCache ? BURN_CACHE_PACKAGE_TYPE_REQUIRED : GetCachePackageType(pPackage, TRUE);
+    pPackage->rollbackCacheType = GetCachePackageType(pPackage, FALSE);
+
+    if (BURN_CACHE_PACKAGE_TYPE_NONE != pPackage->executeCacheType || BURN_CACHE_PACKAGE_TYPE_NONE != pPackage->rollbackCacheType)
     {
-        hr = AddCachePackage(pPlan, pPackage);
+        hr = AddCachePackage(pPlan, pPackage, BURN_CACHE_PACKAGE_TYPE_REQUIRED == pPackage->executeCacheType);
         ExitOnFailure(hr, "Failed to plan cache package.");
     }
-    else if (!pPackage->fCached && NeedsCache(pPackage, FALSE))
-    {
-        // TODO: this decision should be made during apply instead of plan based on whether the package is actually cached.
-        // If the package is not in the cache, disable any rollback that would require the package from the cache.
-        LogId(REPORT_STANDARD, MSG_PLAN_DISABLING_ROLLBACK_NO_CACHE, pPackage->sczId, LoggingActionStateToString(pPackage->rollback));
-        pPackage->rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
-    }
 
     // Add execute actions.
     switch (pPackage->type)
@@ -1364,6 +1364,8 @@ extern "C" HRESULT PlanRelatedBundlesInitialize(
         pRelatedBundle->package.requested = BOOTSTRAPPER_REQUEST_STATE_NONE;
         pRelatedBundle->defaultPlanRelationType = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_NONE;
         pRelatedBundle->planRelationType = BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE_NONE;
+        pRelatedBundle->package.executeCacheType = BURN_CACHE_PACKAGE_TYPE_NONE;
+        pRelatedBundle->package.rollbackCacheType = BURN_CACHE_PACKAGE_TYPE_NONE;
 
         // Determine the plan relation type even if later it is ignored due to the planned action, the command relation type, or the related bundle not being plannable.
         // This gives more information to the BA in case it wants to override default behavior.
@@ -2088,10 +2090,6 @@ static void UninitializeCacheAction(
 {
     switch (pCacheAction->type)
     {
-    case BURN_CACHE_ACTION_TYPE_SIGNAL_SYNCPOINT:
-        ReleaseHandle(pCacheAction->syncpoint.hEvent);
-        break;
-
     case BURN_CACHE_ACTION_TYPE_LAYOUT_BUNDLE:
         ReleaseStr(pCacheAction->bundleLayout.sczExecutableName);
         ReleaseStr(pCacheAction->bundleLayout.sczUnverifiedPath);
@@ -2145,7 +2143,7 @@ static void ResetPlannedPackageState(
     pPackage->cacheType = pPackage->authoredCacheType;
     pPackage->defaultRequested = BOOTSTRAPPER_REQUEST_STATE_NONE;
     pPackage->requested = BOOTSTRAPPER_REQUEST_STATE_NONE;
-    pPackage->fPlannedCache = FALSE;
+    pPackage->fCacheVital = FALSE;
     pPackage->fPlannedUncache = FALSE;
     pPackage->execute = BOOTSTRAPPER_ACTION_STATE_NONE;
     pPackage->rollback = BOOTSTRAPPER_ACTION_STATE_NONE;
@@ -2156,7 +2154,9 @@ static void ResetPlannedPackageState(
     pPackage->fDependencyManagerWasHere = FALSE;
     pPackage->expectedCacheRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN;
     pPackage->expectedInstallRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_UNKNOWN;
-    pPackage->hCacheEvent = NULL;
+    pPackage->executeCacheType = BURN_CACHE_PACKAGE_TYPE_NONE;
+    pPackage->rollbackCacheType = BURN_CACHE_PACKAGE_TYPE_NONE;
+    ReleaseHandle(pPackage->hCacheEvent);
 
     ReleaseNullStr(pPackage->sczCacheFolder);
 
@@ -2314,19 +2314,21 @@ LExit:
 
 static HRESULT AddCachePackage(
     __in BURN_PLAN* pPlan,
-    __in BURN_PACKAGE* pPackage
+    __in BURN_PACKAGE* pPackage,
+    __in BOOL fVital
     )
 {
     HRESULT hr = S_OK;
 
     // If this is an MSI package with slipstream MSPs, ensure the MSPs are cached first.
-    if (BURN_PACKAGE_TYPE_MSI == pPackage->type && 0 < pPackage->Msi.cSlipstreamMspPackages)
+    // TODO: Slipstream packages are not accounted for when caching the MSI package is optional.
+    if (BURN_PACKAGE_TYPE_MSI == pPackage->type && 0 < pPackage->Msi.cSlipstreamMspPackages && fVital)
     {
         hr = AddCacheSlipstreamMsps(pPlan, pPackage);
         ExitOnFailure(hr, "Failed to plan slipstream patches for package.");
     }
 
-    hr = AddCachePackageHelper(pPlan, pPackage);
+    hr = AddCachePackageHelper(pPlan, pPackage, fVital);
     ExitOnFailure(hr, "Failed to plan cache package.");
 
 LExit:
@@ -2335,7 +2337,8 @@ LExit:
 
 static HRESULT AddCachePackageHelper(
     __in BURN_PLAN* pPlan,
-    __in BURN_PACKAGE* pPackage
+    __in BURN_PACKAGE* pPackage,
+    __in BOOL fVital
     )
 {
     AssertSz(pPackage->sczCacheId && *pPackage->sczCacheId, "AddCachePackageHelper() expects the package to have a cache id.");
@@ -2354,6 +2357,9 @@ static HRESULT AddCachePackageHelper(
         ExitFunction();
     }
 
+    pPackage->hCacheEvent = ::CreateEventW(NULL, TRUE, FALSE, NULL);
+    ExitOnNullWithLastError(pPackage->hCacheEvent, hr, "Failed to create syncpoint event.");
+
     // Cache checkpoints happen before the package is cached because downloading packages'
     // payloads will not roll themselves back the way installation packages rollback on
     // failure automatically.
@@ -2381,7 +2387,7 @@ static HRESULT AddCachePackageHelper(
         pCacheAction->checkpoint.dwId = dwCheckpoint;
     }
 
-    hr = PlanLayoutPackage(pPlan, pPackage);
+    hr = PlanLayoutPackage(pPlan, pPackage, fVital);
     ExitOnFailure(hr, "Failed to plan cache for package.");
 
     // Create syncpoint action.
@@ -2389,15 +2395,11 @@ static HRESULT AddCachePackageHelper(
     ExitOnFailure(hr, "Failed to append cache action.");
 
     pCacheAction->type = BURN_CACHE_ACTION_TYPE_SIGNAL_SYNCPOINT;
-    pCacheAction->syncpoint.hEvent = ::CreateEventW(NULL, TRUE, FALSE, NULL);
-    ExitOnNullWithLastError(pCacheAction->syncpoint.hEvent, hr, "Failed to create syncpoint event.");
-
-    pPackage->hCacheEvent = pCacheAction->syncpoint.hEvent;
+    pCacheAction->syncpoint.pPackage = pPackage;
 
     hr = PlanExecuteCacheSyncAndRollback(pPlan, pPackage);
     ExitOnFailure(hr, "Failed to plan package cache syncpoint");
 
-    pPackage->fPlannedCache = TRUE;
     if (pPackage->fCanAffectRegistration)
     {
         pPackage->expectedCacheRegistrationState = BURN_PACKAGE_REGISTRATION_STATE_PRESENT;
@@ -2421,7 +2423,7 @@ static HRESULT AddCacheSlipstreamMsps(
         BURN_PACKAGE* pMspPackage = pPackage->Msi.rgSlipstreamMsps[i].pMspPackage;
         AssertSz(BURN_PACKAGE_TYPE_MSP == pMspPackage->type, "Only MSP packages can be slipstream patches.");
 
-        hr = AddCachePackageHelper(pPlan, pMspPackage);
+        hr = AddCachePackageHelper(pPlan, pMspPackage, TRUE);
         ExitOnFailure(hr, "Failed to plan slipstream MSP: %ls", pMspPackage->sczId);
     }
 
@@ -2791,22 +2793,41 @@ LExit:
     return hr;
 }
 
-static BOOL NeedsCache(
+static BURN_CACHE_PACKAGE_TYPE GetCachePackageType(
     __in BURN_PACKAGE* pPackage,
     __in BOOL fExecute
     )
 {
-    BOOTSTRAPPER_ACTION_STATE action = fExecute ? pPackage->execute : pPackage->rollback;
-    // TODO: bundles could theoretically use package cache
-    if (BURN_PACKAGE_TYPE_BUNDLE == pPackage->type || // Bundle and Exe packages require the package for all operations (even uninstall).
-        BURN_PACKAGE_TYPE_EXE == pPackage->type && BURN_EXE_DETECTION_TYPE_ARP != pPackage->Exe.detectionType)
-    {
-        return BOOTSTRAPPER_ACTION_STATE_NONE != action;
-    }
-    else // The other package types can uninstall without the original package.
+    BURN_CACHE_PACKAGE_TYPE cachePackageType = BURN_CACHE_PACKAGE_TYPE_NONE;
+
+    switch (fExecute ? pPackage->execute : pPackage->rollback)
     {
-        return BOOTSTRAPPER_ACTION_STATE_UNINSTALL < action;
+    case BOOTSTRAPPER_ACTION_STATE_NONE:
+        break;
+    case BOOTSTRAPPER_ACTION_STATE_UNINSTALL:
+        if (BURN_PACKAGE_TYPE_BUNDLE == pPackage->type ||
+            BURN_PACKAGE_TYPE_EXE == pPackage->type && BURN_EXE_DETECTION_TYPE_ARP != pPackage->Exe.detectionType)
+        {
+            // Bundle and non-ArpEntry Exe packages require the package for all operations (even uninstall).
+            // TODO: bundles could theoretically use package cache.
+            cachePackageType = BURN_CACHE_PACKAGE_TYPE_REQUIRED;
+        }
+        else
+        {
+            // The other package types can uninstall without the original package.
+            cachePackageType = BURN_CACHE_PACKAGE_TYPE_NONE;
+        }
+        break;
+    case BOOTSTRAPPER_ACTION_STATE_INSTALL: __fallthrough;
+    case BOOTSTRAPPER_ACTION_STATE_MODIFY: __fallthrough;
+    case BOOTSTRAPPER_ACTION_STATE_REPAIR: __fallthrough;
+    case BOOTSTRAPPER_ACTION_STATE_MINOR_UPGRADE: __fallthrough;
+    default:
+        cachePackageType = BURN_CACHE_PACKAGE_TYPE_REQUIRED;
+        break;
     }
+
+    return cachePackageType;
 }
 
 static BOOL ForceCache(
@@ -2881,7 +2902,7 @@ static void CacheActionLog(
         break;
 
     case BURN_CACHE_ACTION_TYPE_PACKAGE:
-        LogStringLine(PlanDumpLevel, "%ls action[%u]: PACKAGE id: %ls", wzBase, iAction, pAction->package.pPackage->sczId);
+        LogStringLine(PlanDumpLevel, "%ls action[%u]: PACKAGE id: %ls, vital: %hs, execute cache type: %hs, rollback cache type: %hs", wzBase, iAction, pAction->package.pPackage->sczId, LoggingBoolToString(pAction->package.pPackage->fCacheVital), LoggingCachePackageTypeToString(pAction->package.pPackage->executeCacheType), LoggingCachePackageTypeToString(pAction->package.pPackage->rollbackCacheType));
         break;
 
     case BURN_CACHE_ACTION_TYPE_ROLLBACK_PACKAGE:
@@ -2889,7 +2910,7 @@ static void CacheActionLog(
         break;
 
     case BURN_CACHE_ACTION_TYPE_SIGNAL_SYNCPOINT:
-        LogStringLine(PlanDumpLevel, "%ls action[%u]: SIGNAL_SYNCPOINT event handle: 0x%p", wzBase, iAction, pAction->syncpoint.hEvent);
+        LogStringLine(PlanDumpLevel, "%ls action[%u]: SIGNAL_SYNCPOINT package id: %ls, event handle: 0x%p", wzBase, iAction, pAction->syncpoint.pPackage->sczId, pAction->syncpoint.pPackage->hCacheEvent);
         break;
 
     default:
diff --git a/src/burn/engine/plan.h b/src/burn/engine/plan.h
index 46a9a363..386de2c6 100644
--- a/src/burn/engine/plan.h
+++ b/src/burn/engine/plan.h
@@ -117,7 +117,7 @@ typedef struct _BURN_CACHE_ACTION
         } rollbackPackage;
         struct
         {
-            HANDLE hEvent;
+            BURN_PACKAGE* pPackage;
         } syncpoint;
         struct
         {
@@ -392,7 +392,8 @@ HRESULT PlanLayoutContainer(
     );
 HRESULT PlanLayoutPackage(
     __in BURN_PLAN* pPlan,
-    __in BURN_PACKAGE* pPackage
+    __in BURN_PACKAGE* pPackage,
+    __in BOOL fVital
     );
 HRESULT PlanExecutePackage(
     __in BOOL fPerMachine,
diff --git a/src/burn/engine/userexperience.cpp b/src/burn/engine/userexperience.cpp
index 87ef4de1..a97234ef 100644
--- a/src/burn/engine/userexperience.cpp
+++ b/src/burn/engine/userexperience.cpp
@@ -104,7 +104,7 @@ extern "C" HRESULT UserExperienceLoad(
     args.pCommand = pCommand;
     args.pfnBootstrapperEngineProc = EngineForApplicationProc;
     args.pvBootstrapperEngineProcContext = pEngineContext;
-    args.qwEngineAPIVersion = MAKEQWORDVERSION(2022, 3, 31, 0);
+    args.qwEngineAPIVersion = MAKEQWORDVERSION(2022, 6, 10, 0);
 
     results.cbSize = sizeof(BOOTSTRAPPER_CREATE_RESULTS);
 
@@ -726,7 +726,8 @@ EXTERN_C BAAPI UserExperienceOnCachePackageBegin(
     __in BURN_USER_EXPERIENCE* pUserExperience,
     __in_z LPCWSTR wzPackageId,
     __in DWORD cCachePayloads,
-    __in DWORD64 dw64PackageCacheSize
+    __in DWORD64 dw64PackageCacheSize,
+    __in BOOL fVital
     )
 {
     HRESULT hr = S_OK;
@@ -737,6 +738,7 @@ EXTERN_C BAAPI UserExperienceOnCachePackageBegin(
     args.wzPackageId = wzPackageId;
     args.cCachePayloads = cCachePayloads;
     args.dw64PackageCacheSize = dw64PackageCacheSize;
+    args.fVital = fVital;
 
     results.cbSize = sizeof(results);
 
@@ -783,6 +785,40 @@ LExit:
     return hr;
 }
 
+EXTERN_C BAAPI UserExperienceOnCachePackageNonVitalValidationFailure(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in HRESULT hrStatus,
+    __inout BOOTSTRAPPER_CACHEPACKAGENONVITALVALIDATIONFAILURE_ACTION* pAction
+    )
+{
+    HRESULT hr = S_OK;
+    BA_ONCACHEPACKAGENONVITALVALIDATIONFAILURE_ARGS args = { };
+    BA_ONCACHEPACKAGENONVITALVALIDATIONFAILURE_RESULTS results = { };
+
+    args.cbSize = sizeof(args);
+    args.wzPackageId = wzPackageId;
+    args.hrStatus = hrStatus;
+    args.recommendation = *pAction;
+
+    results.cbSize = sizeof(results);
+    results.action = *pAction;
+
+    hr = SendBAMessage(pUserExperience, BOOTSTRAPPER_APPLICATION_MESSAGE_ONCACHEPACKAGENONVITALVALIDATIONFAILURE, &args, &results);
+    ExitOnFailure(hr, "BA OnCachePackageNonVitalValidationFailure failed.");
+
+    switch (results.action)
+    {
+    case BOOTSTRAPPER_CACHEPACKAGENONVITALVALIDATIONFAILURE_ACTION_NONE: __fallthrough;
+    case BOOTSTRAPPER_CACHEPACKAGENONVITALVALIDATIONFAILURE_ACTION_ACQUIRE:
+        *pAction = results.action;
+        break;
+    }
+
+LExit:
+    return hr;
+}
+
 EXTERN_C BAAPI UserExperienceOnCachePayloadExtractBegin(
     __in BURN_USER_EXPERIENCE* pUserExperience,
     __in_z_opt LPCWSTR wzContainerId,
diff --git a/src/burn/engine/userexperience.h b/src/burn/engine/userexperience.h
index 94b73f7d..9f183208 100644
--- a/src/burn/engine/userexperience.h
+++ b/src/burn/engine/userexperience.h
@@ -189,7 +189,14 @@ BAAPI UserExperienceOnCachePackageBegin(
     __in BURN_USER_EXPERIENCE* pUserExperience,
     __in_z LPCWSTR wzPackageId,
     __in DWORD cCachePayloads,
-    __in DWORD64 dw64PackageCacheSize
+    __in DWORD64 dw64PackageCacheSize,
+    __in BOOL fVital
+    );
+BAAPI UserExperienceOnCachePackageNonVitalValidationFailure(
+    __in BURN_USER_EXPERIENCE* pUserExperience,
+    __in_z LPCWSTR wzPackageId,
+    __in HRESULT hrStatus,
+    __inout BOOTSTRAPPER_CACHEPACKAGENONVITALVALIDATIONFAILURE_ACTION* pAction
     );
 BAAPI UserExperienceOnCachePackageComplete(
     __in BURN_USER_EXPERIENCE* pUserExperience,