diff --git a/platform/android/MapLibreAndroidTestApp/build.gradle.kts b/platform/android/MapLibreAndroidTestApp/build.gradle.kts
index f664ec276..249647c92 100644
--- a/platform/android/MapLibreAndroidTestApp/build.gradle.kts
+++ b/platform/android/MapLibreAndroidTestApp/build.gradle.kts
@@ -16,6 +16,9 @@ fun obtainTestBuildType(): String {
     }
 }
 
+val stripValidationNativeDebugSymbols =
+    providers.gradleProperty("maplibre.validation.stripNativeDebugSymbols").orNull == "true"
+
 android {
     ndkVersion = Versions.ndkVersion
 
@@ -51,7 +54,9 @@ android {
 
             packaging {
                 jniLibs {
-                    keepDebugSymbols += "**/*.so"
+                    if (!stripValidationNativeDebugSymbols) {
+                        keepDebugSymbols += "**/*.so"
+                    }
                 }
             }
 
diff --git a/src/mbgl/renderer/render_orchestrator.cpp b/src/mbgl/renderer/render_orchestrator.cpp
index dcd7fabb5..7a2db2413 100644
--- a/src/mbgl/renderer/render_orchestrator.cpp
+++ b/src/mbgl/renderer/render_orchestrator.cpp
@@ -856,8 +856,18 @@ bool RenderOrchestrator::hasTransitions(TimePoint timePoint) const {
     return false;
 }
 
+bool RenderOrchestrator::retainedUnderlayUsesPlacement(int32_t boundary) const {
+    const auto staticLayerCount = std::min<std::size_t>(
+        boundary > 0 ? static_cast<std::size_t>(boundary) : 0, orderedLayers.size());
+    for (std::size_t index = 0; index < staticLayerCount; ++index) {
+        if (orderedLayers[index].get().needsPlacement()) return true;
+    }
+    return false;
+}
+
 bool RenderOrchestrator::retainedUnderlayIsStable(TimePoint timePoint, int32_t boundary) const {
-    if (renderLight.hasTransition() || placementController.hasTransitions(timePoint)) return false;
+    if (renderLight.hasTransition()) return false;
+    if (retainedUnderlayUsesPlacement(boundary) && placementController.hasTransitions(timePoint)) return false;
 
     const auto staticLayerCount = std::min<std::size_t>(
         boundary > 0 ? static_cast<std::size_t>(boundary) : 0, orderedLayers.size());
diff --git a/src/mbgl/renderer/render_orchestrator.hpp b/src/mbgl/renderer/render_orchestrator.hpp
index 97f7baef3..5395b5b8c 100644
--- a/src/mbgl/renderer/render_orchestrator.hpp
+++ b/src/mbgl/renderer/render_orchestrator.hpp
@@ -109,6 +109,7 @@ public:
     bool removeLayerGroup(const LayerGroupBasePtr&);
     size_t numLayerGroups() const noexcept;
     std::optional<int32_t> getRetainedDynamicBoundary() const noexcept { return retainedDynamicBoundary; }
+    bool retainedUnderlayUsesPlacement(int32_t boundary) const;
     bool retainedUnderlayIsStable(TimePoint, int32_t boundary) const;
     void updateLayerIndex(LayerGroupBasePtr, int32_t newIndex);
 
diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index 1633c566e..ae493e1e8 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -58,7 +58,7 @@ RendererObserver& nullObserver() {
 #ifndef NDEBUG
 constexpr uint64_t RetainedCounterLogIntervalFrames = 120;
 
-void logRetainedRendererCounters() {
+void logRetainedRendererCounters(const RetainedUnderlayCache& cache) {
     const auto snapshot = particle::rendererDebugCounterSnapshot();
     if (snapshot.fullRendererFrame == 0 ||
         snapshot.fullRendererFrame % RetainedCounterLogIntervalFrames != 0) {
@@ -72,6 +72,7 @@ void logRetainedRendererCounters() {
             << " reuse=" << snapshot.retainedUnderlayReuse
             << " fallback=" << snapshot.retainedUnderlayFallback
             << " invalidation=" << snapshot.retainedUnderlayInvalidation
+            << " reason=" << cache.getLastInvalidationReason()
             << " staticDraw=" << snapshot.retainedUnderlayStaticGroupDraw
             << " dynamicDraw=" << snapshot.retainedDynamicGroupDraw
             << " particleAdvance=" << snapshot.particleSimulationAdvance;
@@ -310,25 +311,28 @@ void Renderer::Impl::render(const RenderTree& renderTree, const std::shared_ptr<
             }
         }
     }
+    const bool retainedStaticUsesPlacement =
+        retainedBoundary && orchestrator.retainedUnderlayUsesPlacement(*retainedBoundary);
+    const bool retainedStaticStable =
+        retainedBoundary && orchestrator.retainedUnderlayIsStable(renderTreeParameters.timePoint, *retainedBoundary);
+    const bool retainedPlacementStable =
+        !retainedStaticUsesPlacement ||
+        (!renderTreeParameters.placementChanged && renderTreeParameters.symbolFadeChange == 0.0f);
     const bool retainedSupported = retainedBoundary && retainedStaticGroupCount > 0 &&
                                    renderTreeParameters.loaded && !renderTreeParameters.has3D &&
                                    renderTreeParameters.debugOptions == MapDebugOptions::NoDebug &&
-                                   orchestrator.retainedUnderlayIsStable(renderTreeParameters.timePoint,
-                                                                         *retainedBoundary) &&
-                                   !renderTreeParameters.placementChanged &&
-                                   renderTreeParameters.symbolFadeChange == 0.0f &&
+                                   retainedStaticStable && retainedPlacementStable &&
                                    !legacyBelowBoundary;
-    const char* retainedFallbackReason = !retainedBoundary            ? "no-boundary"
+    const char* retainedFallbackReason = !retainedBoundary               ? "no-boundary"
                                            : retainedStaticGroupCount == 0 ? "empty-static-prefix"
-                                           : !renderTreeParameters.loaded ? "style-not-loaded"
-                                           : renderTreeParameters.has3D   ? "3d"
+                                           : !renderTreeParameters.loaded  ? "style-not-loaded"
+                                           : renderTreeParameters.has3D    ? "3d"
                                            : renderTreeParameters.debugOptions != MapDebugOptions::NoDebug
                                                ? "debug-options"
-                                           : !orchestrator.retainedUnderlayIsStable(renderTreeParameters.timePoint,
-                                                                                     *retainedBoundary) ||
-                                                   renderTreeParameters.placementChanged ||
-                                                   renderTreeParameters.symbolFadeChange != 0.0f
-                                               ? "static-transition-or-placement"
+                                           : !retainedStaticStable
+                                               ? "static-transition"
+                                           : !retainedPlacementStable
+                                               ? "static-placement"
                                            : legacyBelowBoundary ? "legacy-ordering"
                                                                  : nullptr;
     auto retainedDecision = retainedUnderlayCache->evaluate(retainedKey,
@@ -619,7 +623,7 @@ void Renderer::Impl::render(const RenderTree& renderTree, const std::shared_ptr<
     }
 
 #ifndef NDEBUG
-    logRetainedRendererCounters();
+    logRetainedRendererCounters(*retainedUnderlayCache);
 #endif
 
     frameCount += 1;