From 89017a853a12b0161879e5ff1063b92d11e022b0 Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Fri, 15 Aug 2025 22:12:49 -0400
Subject: [PATCH 01/19] add error msgs

---
 styles/layers.h | 38 +++++++++++++++++++++++++++++++++++---
 1 file changed, 35 insertions(+), 3 deletions(-)

diff --git a/styles/layers.h b/styles/layers.h
index dcf434ac9..41847aead 100644
--- a/styles/layers.h
+++ b/styles/layers.h
@@ -4,6 +4,15 @@
 #include "alpha.h"
 #include "../functions/int.h"
 #include "colors.h"
+#include <type_traits>
+#include <utility>
+
+// Identify “solid” colors by the return type of getColor()
+namespace layers_detail {
+  template<typename T> struct IsOpaqueColor : std::false_type {};
+  template<> struct IsOpaqueColor<SimpleColor> : std::true_type {};
+  template<> struct IsOpaqueColor<OverDriveColor> : std::true_type {};
+}
 
 // Usage: Layers<BASE, LAYER1, LAYER2, ...>
 // BASE: COLOR or LAYER
@@ -73,12 +82,35 @@ class Compose<BLACK, L1> {
   }
 };
 
-
 template<class BASE, class ... LAYERS> struct LayerSelector {};
 template<class BASE> struct LayerSelector<BASE> { typedef BASE type; };
 template<class BASE, class L1> struct LayerSelector<AlphaL<BASE, Int<0>>, L1> { typedef L1 type; };
-template<class BASE, class L1> struct LayerSelector<BASE, L1> { typedef Compose<BASE, L1> type; };
-template<class BASE, class L1, class ... REST> struct LayerSelector<BASE, L1, REST...> {
+
+// If base is exactly AlphaL<*, Int<0>> and there are 3+ args, drop it early
+template<class BASE, class L1, class L2, class... REST>
+struct LayerSelector<AlphaL<BASE, Int<0>>, L1, L2, REST...> {
+  typedef typename LayerSelector<L1, L2, REST...>::type type;
+};
+
+// Solid+solid check
+template<class BASE, class L1>
+struct LayerSelector<BASE, L1> {
+  using BaseColorT  = decltype(std::declval<BASE&>().getColor(0));
+  using LayerColorT = decltype(std::declval<L1&>().getColor(0));
+  static_assert(!(layers_detail::IsOpaqueColor<BaseColorT>::value &&
+                  layers_detail::IsOpaqueColor<LayerColorT>::value),
+                "Layers<> error: *** CANNOT STACK TWO SOLID COLORS. ***");
+  typedef Compose<BASE, L1> type;
+};
+
+// Recursive
+template<class BASE, class L1, class ... REST>
+struct LayerSelector<BASE, L1, REST...> {
+  using BaseColorT  = decltype(std::declval<BASE&>().getColor(0));
+  using LayerColorT = decltype(std::declval<L1&>().getColor(0));
+  static_assert(!(layers_detail::IsOpaqueColor<BaseColorT>::value &&
+                  layers_detail::IsOpaqueColor<LayerColorT>::value),
+                "Layers<> error: *** CANNOT STACK TWO SOLID COLORS. ***");
   typedef typename LayerSelector<Compose<BASE, L1>, REST...>::type type;
 };
 

From 00d33c515674c6c745bdcfcaf87b3a7dd6f5a1e6 Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Fri, 15 Aug 2025 22:13:39 -0400
Subject: [PATCH 02/19] add error msgs

---
 styles/style_ptr.h | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/styles/style_ptr.h b/styles/style_ptr.h
index 0c85ad8ea..4cd2196da 100644
--- a/styles/style_ptr.h
+++ b/styles/style_ptr.h
@@ -3,6 +3,17 @@
 
 #include "blade_style.h"
 
+template<class BASE, class L1> class Compose;  // forward-declare Layers node
+
+namespace style_base_check_detail {
+  template<class T> struct TopBase { using type = T; };
+  template<class B, class L> struct TopBase<Compose<B,L>> : TopBase<B> {};
+
+  template<typename T> struct IsOpaqueColor : std::false_type {};
+  template<> struct IsOpaqueColor<SimpleColor> : std::true_type {};
+  template<> struct IsOpaqueColor<OverDriveColor> : std::true_type {};
+}
+
 // Usage: StylePtr<BLADE>
 // BLADE: COLOR
 // return value: suitable for preset array
@@ -133,6 +144,10 @@ class ChargingStyle : public Style<T> {
 // Get a pointer to class.
 template<class STYLE>
 StyleAllocator StylePtr() {
+  using _TopBaseT  = typename style_base_check_detail::TopBase<STYLE>::type;
+  using _TopBaseCol = decltype(std::declval<_TopBaseT&>().getColor(0));
+  static_assert(style_base_check_detail::IsOpaqueColor<_TopBaseCol>::value,
+                "StylePtr<> error: *** BASE LAYER MUST BE A SOLID COLOR, NOT TRANSPARENT (No \"L\" layers). ***");
   static StyleFactoryImpl<Style<STYLE> > factory;
   return &factory;
 };
@@ -140,7 +155,7 @@ StyleAllocator StylePtr() {
 class StyleFactoryWithDefault : public StyleFactory {
 public:
   StyleFactoryWithDefault(StyleFactory* allocator,
-			  const char* default_arguments) :
+        const char* default_arguments) :
     allocator_(allocator), default_arguments_(default_arguments) {
   }
   BladeStyle* make() override {
@@ -164,6 +179,10 @@ StyleAllocator StylePtr(const char* default_arguments) {
 // that you can't turn it on/off, and the battery low warning is disabled.
 template<class STYLE>
 StyleAllocator ChargingStylePtr() {
+  using _TopBaseT  = typename style_base_check_detail::TopBase<STYLE>::type;
+  using _TopBaseCol = decltype(std::declval<_TopBaseT&>().getColor(0));
+  static_assert(style_base_check_detail::IsOpaqueColor<_TopBaseCol>::value,
+                "StylePtr<> error: *** BASE LAYER MUST BE A SOLID COLOR, NOT TRANSPARENT (No \"L\" layers). ***");
   static StyleFactoryImpl<ChargingStyle<STYLE> > factory;
   return &factory;
 }

From 9f4dd41c186bcf88517fc498e175f2327473e6b3 Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Fri, 15 Aug 2025 23:28:58 -0400
Subject: [PATCH 03/19] Move IsOpaqueColor trait into common/color.h

---
 common/color.h | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/common/color.h b/common/color.h
index 8e3076493..72ec68ed4 100644
--- a/common/color.h
+++ b/common/color.h
@@ -1,6 +1,8 @@
 #ifndef COMMON_COLOR_H
 #define COMMON_COLOR_H
 
+#include <type_traits>
+
 // Used to represent a color. Uses normal 8-bit-per channel RGB.
 // Note that these colors are in linear space and their interpretation
 // depends on the blade.
@@ -388,6 +390,11 @@ struct OverDriveColor {
   bool getOverdrive() const { return overdrive; }
 };
 
+namespace color_details {
+  template<typename T> struct IsOpaqueColor : std::false_type {};
+  template<> struct IsOpaqueColor<SimpleColor> : std::true_type {};
+  template<> struct IsOpaqueColor<OverDriveColor> : std::true_type {};
+}
 
 // SIMPLE
 // Opaque.fade -> Opaque or Alpha?

From 22685b5ce8de1effa5952a910629283347e3b41f Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Fri, 15 Aug 2025 23:32:07 -0400
Subject: [PATCH 04/19] Remove IsOpaqueColor from style_ptr.h and layers.h

And make messages obnoxiously visible so they are easy to find in a sea of "ambiguous overload" errors.
---
 styles/layers.h | 44 +++++++++++++++++++++-----------------------
 1 file changed, 21 insertions(+), 23 deletions(-)

diff --git a/styles/layers.h b/styles/layers.h
index 41847aead..12caf836c 100644
--- a/styles/layers.h
+++ b/styles/layers.h
@@ -7,13 +7,6 @@
 #include <type_traits>
 #include <utility>
 
-// Identify “solid” colors by the return type of getColor()
-namespace layers_detail {
-  template<typename T> struct IsOpaqueColor : std::false_type {};
-  template<> struct IsOpaqueColor<SimpleColor> : std::true_type {};
-  template<> struct IsOpaqueColor<OverDriveColor> : std::true_type {};
-}
-
 // Usage: Layers<BASE, LAYER1, LAYER2, ...>
 // BASE: COLOR or LAYER
 // LAYER1, LAYER2: LAYER
@@ -82,24 +75,22 @@ class Compose<BLACK, L1> {
   }
 };
 
-template<class BASE, class ... LAYERS> struct LayerSelector {};
-template<class BASE> struct LayerSelector<BASE> { typedef BASE type; };
-template<class BASE, class L1> struct LayerSelector<AlphaL<BASE, Int<0>>, L1> { typedef L1 type; };
-
-// If base is exactly AlphaL<*, Int<0>> and there are 3+ args, drop it early
-template<class BASE, class L1, class L2, class... REST>
-struct LayerSelector<AlphaL<BASE, Int<0>>, L1, L2, REST...> {
-  typedef typename LayerSelector<L1, L2, REST...>::type type;
-};
 
-// Solid+solid check
+// Reject solid layers after the first
 template<class BASE, class L1>
 struct LayerSelector<BASE, L1> {
   using BaseColorT  = decltype(std::declval<BASE&>().getColor(0));
   using LayerColorT = decltype(std::declval<L1&>().getColor(0));
-  static_assert(!(layers_detail::IsOpaqueColor<BaseColorT>::value &&
-                  layers_detail::IsOpaqueColor<LayerColorT>::value),
-                "Layers<> error: *** CANNOT STACK TWO SOLID COLORS. ***");
+  static_assert(!(color_details::IsOpaqueColor<BaseColorT>::value &&
+                  color_details::IsOpaqueColor<LayerColorT>::value),
+                "\n\n"
+                "           --------------------------------------------------------------------------\n"
+                "           |              (This is the error you are looking for)                   |\n"
+                "           |                                                                        |\n"
+                "           |            Layers<> ERROR: CANNOT STACK TWO SOLID COLORS.              |\n"
+                "           |                                                                        |\n"
+                "           --------------------------------------------------------------------------\n"
+                "\n\n");
   typedef Compose<BASE, L1> type;
 };
 
@@ -108,9 +99,16 @@ template<class BASE, class L1, class ... REST>
 struct LayerSelector<BASE, L1, REST...> {
   using BaseColorT  = decltype(std::declval<BASE&>().getColor(0));
   using LayerColorT = decltype(std::declval<L1&>().getColor(0));
-  static_assert(!(layers_detail::IsOpaqueColor<BaseColorT>::value &&
-                  layers_detail::IsOpaqueColor<LayerColorT>::value),
-                "Layers<> error: *** CANNOT STACK TWO SOLID COLORS. ***");
+  static_assert(!(color_details::IsOpaqueColor<BaseColorT>::value &&
+                  color_details::IsOpaqueColor<LayerColorT>::value),
+                "\n\n"
+                "           --------------------------------------------------------------------------\n"
+                "           |              (This is the error you are looking for)                   |\n"
+                "           |                                                                        |\n"
+                "           |            Layers<> ERROR: CANNOT STACK TWO SOLID COLORS.              |\n"
+                "           |                                                                        |\n"
+                "           --------------------------------------------------------------------------\n"
+                "\n\n");
   typedef typename LayerSelector<Compose<BASE, L1>, REST...>::type type;
 };
 

From f7565316ed6d1e2c5bd0b08266573ec1064098db Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Fri, 15 Aug 2025 23:33:22 -0400
Subject: [PATCH 05/19] Remove IsOpaqueColor from style_ptr.h and layers.h

And make messages obnoxiously visible so they are easy to find in a sea of "ambiguous overload" errors.
---
 styles/style_ptr.h | 28 ++++++++++++++++++++--------
 1 file changed, 20 insertions(+), 8 deletions(-)

diff --git a/styles/style_ptr.h b/styles/style_ptr.h
index 4cd2196da..69f3504a0 100644
--- a/styles/style_ptr.h
+++ b/styles/style_ptr.h
@@ -8,10 +8,6 @@ template<class BASE, class L1> class Compose;  // forward-declare Layers node
 namespace style_base_check_detail {
   template<class T> struct TopBase { using type = T; };
   template<class B, class L> struct TopBase<Compose<B,L>> : TopBase<B> {};
-
-  template<typename T> struct IsOpaqueColor : std::false_type {};
-  template<> struct IsOpaqueColor<SimpleColor> : std::true_type {};
-  template<> struct IsOpaqueColor<OverDriveColor> : std::true_type {};
 }
 
 // Usage: StylePtr<BLADE>
@@ -146,8 +142,16 @@ template<class STYLE>
 StyleAllocator StylePtr() {
   using _TopBaseT  = typename style_base_check_detail::TopBase<STYLE>::type;
   using _TopBaseCol = decltype(std::declval<_TopBaseT&>().getColor(0));
-  static_assert(style_base_check_detail::IsOpaqueColor<_TopBaseCol>::value,
-                "StylePtr<> error: *** BASE LAYER MUST BE A SOLID COLOR, NOT TRANSPARENT (No \"L\" layers). ***");
+  static_assert(color_details::IsOpaqueColor<_TopBaseCol>::value,
+                "\n\n"
+                "           --------------------------------------------------------------------------\n"
+                "           |              (This is the error you are looking for)                   |\n"
+                "           |                                                                        |\n"
+                "           |  StylePtr<> error: BASE LAYER MUST BE A SOLID COLOR, NOT TRANSPARENT   |\n"
+                "           |              (No \"L\" layers allowed as base layer!)                    |\n"
+                "           |                                                                        |\n"
+                "           --------------------------------------------------------------------------\n"
+                "\n\n");
   static StyleFactoryImpl<Style<STYLE> > factory;
   return &factory;
 };
@@ -181,8 +185,16 @@ template<class STYLE>
 StyleAllocator ChargingStylePtr() {
   using _TopBaseT  = typename style_base_check_detail::TopBase<STYLE>::type;
   using _TopBaseCol = decltype(std::declval<_TopBaseT&>().getColor(0));
-  static_assert(style_base_check_detail::IsOpaqueColor<_TopBaseCol>::value,
-                "StylePtr<> error: *** BASE LAYER MUST BE A SOLID COLOR, NOT TRANSPARENT (No \"L\" layers). ***");
+  static_assert(color_details::IsOpaqueColor<_TopBaseCol>::value,
+                "\n\n"
+                "           --------------------------------------------------------------------------\n"
+                "           |              (This is the error you are looking for)                   |\n"
+                "           |                                                                        |\n"
+                "           |  StylePtr<> error: BASE LAYER MUST BE A SOLID COLOR, NOT TRANSPARENT   |\n"
+                "           |              (No \"L\" layers allowed as base layer!)                    |\n"
+                "           |                                                                        |\n"
+                "           --------------------------------------------------------------------------\n"
+                "\n\n");
   static StyleFactoryImpl<ChargingStyle<STYLE> > factory;
   return &factory;
 }

From 877ed74edec2b8a707d2b51c0db89a874de99512 Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Sat, 16 Aug 2025 02:23:30 -0400
Subject: [PATCH 06/19] simplify message printout

---
 styles/style_ptr.h | 20 ++++----------------
 1 file changed, 4 insertions(+), 16 deletions(-)

diff --git a/styles/style_ptr.h b/styles/style_ptr.h
index 69f3504a0..7634a88b0 100644
--- a/styles/style_ptr.h
+++ b/styles/style_ptr.h
@@ -144,14 +144,8 @@ StyleAllocator StylePtr() {
   using _TopBaseCol = decltype(std::declval<_TopBaseT&>().getColor(0));
   static_assert(color_details::IsOpaqueColor<_TopBaseCol>::value,
                 "\n\n"
-                "           --------------------------------------------------------------------------\n"
-                "           |              (This is the error you are looking for)                   |\n"
-                "           |                                                                        |\n"
-                "           |  StylePtr<> error: BASE LAYER MUST BE A SOLID COLOR, NOT TRANSPARENT   |\n"
-                "           |              (No \"L\" layers allowed as base layer!)                    |\n"
-                "           |                                                                        |\n"
-                "           --------------------------------------------------------------------------\n"
-                "\n\n");
+                "*** StylePtr<> error: BASE LAYER MUST BE A SOLID COLOR, NOT TRANSPARENT.\n"
+                "*** (No \"L\" layers allowed as base layer!)\n");
   static StyleFactoryImpl<Style<STYLE> > factory;
   return &factory;
 };
@@ -187,14 +181,8 @@ StyleAllocator ChargingStylePtr() {
   using _TopBaseCol = decltype(std::declval<_TopBaseT&>().getColor(0));
   static_assert(color_details::IsOpaqueColor<_TopBaseCol>::value,
                 "\n\n"
-                "           --------------------------------------------------------------------------\n"
-                "           |              (This is the error you are looking for)                   |\n"
-                "           |                                                                        |\n"
-                "           |  StylePtr<> error: BASE LAYER MUST BE A SOLID COLOR, NOT TRANSPARENT   |\n"
-                "           |              (No \"L\" layers allowed as base layer!)                    |\n"
-                "           |                                                                        |\n"
-                "           --------------------------------------------------------------------------\n"
-                "\n\n");
+                "*** StylePtr<> error: BASE LAYER MUST BE A SOLID COLOR, NOT TRANSPARENT.\n"
+                "*** (No \"L\" layers allowed as base layer!)\n");
   static StyleFactoryImpl<ChargingStyle<STYLE> > factory;
   return &factory;
 }

From 8053cf83e50be37d23a9324904320530bc1e6495 Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Sat, 16 Aug 2025 02:26:17 -0400
Subject: [PATCH 07/19] insert the assert into Compose<>

also cover scenarios for Black and Alpha 0 being first
---
 styles/layers.h | 70 ++++++++++++++++++++++++-------------------------
 1 file changed, 34 insertions(+), 36 deletions(-)

diff --git a/styles/layers.h b/styles/layers.h
index 12caf836c..3c195e9fe 100644
--- a/styles/layers.h
+++ b/styles/layers.h
@@ -4,23 +4,31 @@
 #include "alpha.h"
 #include "../functions/int.h"
 #include "colors.h"
-#include <type_traits>
+#include "../common/color.h"
 #include <utility>
 
 // Usage: Layers<BASE, LAYER1, LAYER2, ...>
 // BASE: COLOR or LAYER
 // LAYER1, LAYER2: LAYER
 // return value: COLOR or LAYER (same as BASE)
-// This style works like layers in gimp or photoshop.
-// In most cases, the layers are expected to be normally transparent effects
-// that turn opaque when then want to paint an effect over the base color.
-// If the base color is opqaque, the final result of this style will also be
-// opaque. If the base color is transparent, the final result may also be transparent,
-// depending on what the layers paint on top of the base color.
+// This style works like layers in Photoshop: each layer is painted over the one beneath it.
+// When a Layers<> is used as the first template argument to StylePtr<>, its BASE color (the first layer)
+// must be a solid (opaque) color, not transparent. No additional solid colors may be stacked on top
+// of that solid base.
+// Additional layers stacked on top of a solid base color are transparent,
+// so the base color shows through until an effect wants to paint over it (e.g., a clash).
+// Layers<> can be nested inside other Layers<> and can be used anywhere a STYLE or COLOR is expected.
+
 
 template<class BASE, class L1>
 class Compose {
 public:
+  using _BaseColorT  = decltype(std::declval<BASE&>().getColor(0));
+  using _LayerColorT = decltype(std::declval<L1&>().getColor(0));
+  static_assert(!(color_details::IsOpaqueColor<_BaseColorT>::value &&
+                  color_details::IsOpaqueColor<_LayerColorT>::value),
+                "\n\n"
+                "*** Layers<> ERROR: CANNOT STACK TWO SOLID COLORS.\n\n");
   LayerRunResult run(BladeBase* blade) {
     LayerRunResult base_run_result = RunLayer(&base_, blade);
     LayerRunResult layer_run_result = RunLayer(&layer_, blade);
@@ -75,40 +83,30 @@ class Compose<BLACK, L1> {
   }
 };
 
+template<class BASE, class ... LAYERS> struct LayerSelector {};
+template<class BASE> struct LayerSelector<BASE> { typedef BASE type; };
 
-// Reject solid layers after the first
-template<class BASE, class L1>
-struct LayerSelector<BASE, L1> {
-  using BaseColorT  = decltype(std::declval<BASE&>().getColor(0));
-  using LayerColorT = decltype(std::declval<L1&>().getColor(0));
-  static_assert(!(color_details::IsOpaqueColor<BaseColorT>::value &&
-                  color_details::IsOpaqueColor<LayerColorT>::value),
-                "\n\n"
-                "           --------------------------------------------------------------------------\n"
-                "           |              (This is the error you are looking for)                   |\n"
-                "           |                                                                        |\n"
-                "           |            Layers<> ERROR: CANNOT STACK TWO SOLID COLORS.              |\n"
-                "           |                                                                        |\n"
-                "           --------------------------------------------------------------------------\n"
-                "\n\n");
-  typedef Compose<BASE, L1> type;
+// Drop fully transparent first item (Alpha 0) when there are exactly 2 args.
+template<class BASE, class L1> struct LayerSelector<AlphaL<BASE, Int<0>>, L1> { typedef L1 type; };
+
+// Drop fully transparent first item (Alpha 0) when there are 3+ args.
+template<class BASE, class L1, class L2, class... REST>
+struct LayerSelector<AlphaL<BASE, Int<0>>, L1, L2, REST...> {
+  typedef typename LayerSelector<L1, L2, REST...>::type type;
 };
 
-// Recursive
+// Drop BLACK as first item when there are exactly 2 args.
+template<class L1> struct LayerSelector<BLACK, L1> { typedef L1 type; };
+
+// Drop BLACK as first item when there are 3+ args.
+template<class L1, class L2, class... REST>
+struct LayerSelector<BLACK, L1, L2, REST...> {
+  typedef typename LayerSelector<L1, L2, REST...>::type type;
+};
+
+template<class BASE, class L1> struct LayerSelector<BASE, L1> { typedef Compose<BASE, L1> type; };
 template<class BASE, class L1, class ... REST>
 struct LayerSelector<BASE, L1, REST...> {
-  using BaseColorT  = decltype(std::declval<BASE&>().getColor(0));
-  using LayerColorT = decltype(std::declval<L1&>().getColor(0));
-  static_assert(!(color_details::IsOpaqueColor<BaseColorT>::value &&
-                  color_details::IsOpaqueColor<LayerColorT>::value),
-                "\n\n"
-                "           --------------------------------------------------------------------------\n"
-                "           |              (This is the error you are looking for)                   |\n"
-                "           |                                                                        |\n"
-                "           |            Layers<> ERROR: CANNOT STACK TWO SOLID COLORS.              |\n"
-                "           |                                                                        |\n"
-                "           --------------------------------------------------------------------------\n"
-                "\n\n");
   typedef typename LayerSelector<Compose<BASE, L1>, REST...>::type type;
 };
 

From a6939b36b3fb899c5bf3e2c2cb14023693b5d7d0 Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Sat, 16 Aug 2025 02:41:15 -0400
Subject: [PATCH 08/19] was bypassing Black Compose. removed specializations

---
 styles/layers.h | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/styles/layers.h b/styles/layers.h
index 3c195e9fe..e68000343 100644
--- a/styles/layers.h
+++ b/styles/layers.h
@@ -95,15 +95,6 @@ struct LayerSelector<AlphaL<BASE, Int<0>>, L1, L2, REST...> {
   typedef typename LayerSelector<L1, L2, REST...>::type type;
 };
 
-// Drop BLACK as first item when there are exactly 2 args.
-template<class L1> struct LayerSelector<BLACK, L1> { typedef L1 type; };
-
-// Drop BLACK as first item when there are 3+ args.
-template<class L1, class L2, class... REST>
-struct LayerSelector<BLACK, L1, L2, REST...> {
-  typedef typename LayerSelector<L1, L2, REST...>::type type;
-};
-
 template<class BASE, class L1> struct LayerSelector<BASE, L1> { typedef Compose<BASE, L1> type; };
 template<class BASE, class L1, class ... REST>
 struct LayerSelector<BASE, L1, REST...> {

From 02be38b7c73c1d2db3cdc951f1f7a87858e4fe65 Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Sat, 16 Aug 2025 04:03:45 -0400
Subject: [PATCH 09/19] Use opaque-layer rule in Compose<>

---
 styles/layers.h | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/styles/layers.h b/styles/layers.h
index e68000343..cab83f450 100644
--- a/styles/layers.h
+++ b/styles/layers.h
@@ -23,10 +23,7 @@
 template<class BASE, class L1>
 class Compose {
 public:
-  using _BaseColorT  = decltype(std::declval<BASE&>().getColor(0));
-  using _LayerColorT = decltype(std::declval<L1&>().getColor(0));
-  static_assert(!(color_details::IsOpaqueColor<_BaseColorT>::value &&
-                  color_details::IsOpaqueColor<_LayerColorT>::value),
+static_assert(!color_details::IsOpaqueColor<decltype(std::declval<L1&>().getColor(0))>::value,
                 "\n\n"
                 "*** Layers<> ERROR: CANNOT STACK TWO SOLID COLORS.\n\n");
   LayerRunResult run(BladeBase* blade) {

From 60d2a68da0104e684d96896356cd0308406ee37f Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Sun, 17 Aug 2025 00:28:15 -0400
Subject: [PATCH 10/19] Edit LayerSelector, remove 3 arg case

---
 styles/layers.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/styles/layers.h b/styles/layers.h
index cab83f450..99efa2e13 100644
--- a/styles/layers.h
+++ b/styles/layers.h
@@ -23,7 +23,7 @@
 template<class BASE, class L1>
 class Compose {
 public:
-static_assert(!color_details::IsOpaqueColor<decltype(std::declval<L1&>().getColor(0))>::value,
+  static_assert(!color_details::IsOpaqueColor<decltype(std::declval<L1&>().getColor(0))>::value,
                 "\n\n"
                 "*** Layers<> ERROR: CANNOT STACK TWO SOLID COLORS.\n\n");
   LayerRunResult run(BladeBase* blade) {
@@ -95,7 +95,7 @@ struct LayerSelector<AlphaL<BASE, Int<0>>, L1, L2, REST...> {
 template<class BASE, class L1> struct LayerSelector<BASE, L1> { typedef Compose<BASE, L1> type; };
 template<class BASE, class L1, class ... REST>
 struct LayerSelector<BASE, L1, REST...> {
-  typedef typename LayerSelector<Compose<BASE, L1>, REST...>::type type;
+  typedef typename LayerSelector<typename LayerSelector<BASE, L1>::type, REST...>::type type;
 };
 
 template<class BASE, class... LAYERS> using Layers = typename LayerSelector<BASE, LAYERS...>::type;

From 8e891355146f17ce99a17ab43a4bd4c854899ad6 Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Sun, 17 Aug 2025 00:29:18 -0400
Subject: [PATCH 11/19] edit error msg text

---
 styles/layers.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/styles/layers.h b/styles/layers.h
index 99efa2e13..a70bd2be3 100644
--- a/styles/layers.h
+++ b/styles/layers.h
@@ -25,7 +25,7 @@ class Compose {
 public:
   static_assert(!color_details::IsOpaqueColor<decltype(std::declval<L1&>().getColor(0))>::value,
                 "\n\n"
-                "*** Layers<> ERROR: CANNOT STACK TWO SOLID COLORS.\n\n");
+                "*** Layers<> error: Only the base color may be solid.\n\n");
   LayerRunResult run(BladeBase* blade) {
     LayerRunResult base_run_result = RunLayer(&base_, blade);
     LayerRunResult layer_run_result = RunLayer(&layer_, blade);

From b05e4311c8b92a7f991c93a04625917cf8bdd73c Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Sun, 17 Aug 2025 00:36:35 -0400
Subject: [PATCH 12/19] actually remove 3-arg case for LayerSelector

---
 styles/layers.h | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/styles/layers.h b/styles/layers.h
index a70bd2be3..ea4030aa6 100644
--- a/styles/layers.h
+++ b/styles/layers.h
@@ -86,12 +86,6 @@ template<class BASE> struct LayerSelector<BASE> { typedef BASE type; };
 // Drop fully transparent first item (Alpha 0) when there are exactly 2 args.
 template<class BASE, class L1> struct LayerSelector<AlphaL<BASE, Int<0>>, L1> { typedef L1 type; };
 
-// Drop fully transparent first item (Alpha 0) when there are 3+ args.
-template<class BASE, class L1, class L2, class... REST>
-struct LayerSelector<AlphaL<BASE, Int<0>>, L1, L2, REST...> {
-  typedef typename LayerSelector<L1, L2, REST...>::type type;
-};
-
 template<class BASE, class L1> struct LayerSelector<BASE, L1> { typedef Compose<BASE, L1> type; };
 template<class BASE, class L1, class ... REST>
 struct LayerSelector<BASE, L1, REST...> {
@@ -100,4 +94,5 @@ struct LayerSelector<BASE, L1, REST...> {
 
 template<class BASE, class... LAYERS> using Layers = typename LayerSelector<BASE, LAYERS...>::type;
 
+
 #endif

From ee1b44e1ada4f1cf92571c40838db9cc85b4f2f8 Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Mon, 18 Aug 2025 00:17:22 -0400
Subject: [PATCH 13/19] try to clean up and make all work again

---
 styles/layers.h | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/styles/layers.h b/styles/layers.h
index ea4030aa6..524430dc3 100644
--- a/styles/layers.h
+++ b/styles/layers.h
@@ -11,7 +11,9 @@
 // BASE: COLOR or LAYER
 // LAYER1, LAYER2: LAYER
 // return value: COLOR or LAYER (same as BASE)
-// This style works like layers in Photoshop: each layer is painted over the one beneath it.
+// This style works like layers in Photoshop: each layer adds to the stack covering the base. 
+// The written order of layers in the blade style code puts the base first, with any following layers visually covering it.
+//
 // When a Layers<> is used as the first template argument to StylePtr<>, its BASE color (the first layer)
 // must be a solid (opaque) color, not transparent. No additional solid colors may be stacked on top
 // of that solid base.
@@ -19,11 +21,13 @@
 // so the base color shows through until an effect wants to paint over it (e.g., a clash).
 // Layers<> can be nested inside other Layers<> and can be used anywhere a STYLE or COLOR is expected.
 
-
 template<class BASE, class L1>
 class Compose {
 public:
-  static_assert(!color_details::IsOpaqueColor<decltype(std::declval<L1&>().getColor(0))>::value,
+  using _BaseColorT  = decltype(std::declval<BASE&>().getColor(0));
+  using _LayerColorT = decltype(std::declval<L1&>().getColor(0));
+  static_assert(!(color_details::IsOpaqueColor<_BaseColorT>::value &&
+                  color_details::IsOpaqueColor<_LayerColorT>::value),
                 "\n\n"
                 "*** Layers<> error: Only the base color may be solid.\n\n");
   LayerRunResult run(BladeBase* blade) {
@@ -86,6 +90,19 @@ template<class BASE> struct LayerSelector<BASE> { typedef BASE type; };
 // Drop fully transparent first item (Alpha 0) when there are exactly 2 args.
 template<class BASE, class L1> struct LayerSelector<AlphaL<BASE, Int<0>>, L1> { typedef L1 type; };
 
+// Drop fully transparent when it’s the second (right) item in a pair.
+template<class BASE, class ABASE>
+struct LayerSelector<BASE, AlphaL<ABASE, Int<0>>> { typedef BASE type; };
+
+// Drop BLACK when it’s first (two-arg case).
+template<class L1>
+struct LayerSelector<BLACK, L1> { typedef L1 type; };
+
+// Drop BLACK when it’s first (recursive case).
+template<class L1, class... REST>
+struct LayerSelector<BLACK, L1, REST...> {
+  typedef typename LayerSelector<L1, REST...>::type type;
+};
 template<class BASE, class L1> struct LayerSelector<BASE, L1> { typedef Compose<BASE, L1> type; };
 template<class BASE, class L1, class ... REST>
 struct LayerSelector<BASE, L1, REST...> {
@@ -94,5 +111,4 @@ struct LayerSelector<BASE, L1, REST...> {
 
 template<class BASE, class... LAYERS> using Layers = typename LayerSelector<BASE, LAYERS...>::type;
 
-
 #endif

From 0f0f6d28d20aee0aa23d47bc22ca317312035a4d Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Mon, 18 Aug 2025 00:19:17 -0400
Subject: [PATCH 14/19] move assert into style_base_check_detail

---
 styles/style_ptr.h | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/styles/style_ptr.h b/styles/style_ptr.h
index 7634a88b0..c2f6a3fd1 100644
--- a/styles/style_ptr.h
+++ b/styles/style_ptr.h
@@ -8,6 +8,14 @@ template<class BASE, class L1> class Compose;  // forward-declare Layers node
 namespace style_base_check_detail {
   template<class T> struct TopBase { using type = T; };
   template<class B, class L> struct TopBase<Compose<B,L>> : TopBase<B> {};
+  template<class STYLE>
+  inline void AssertLayersBaseOpaque() {
+    using _TopBaseT  = typename TopBase<STYLE>::type;
+    using _TopBaseCol = decltype(std::declval<_TopBaseT&>().getColor(0));
+    static_assert(color_details::IsOpaqueColor<_TopBaseCol>::value,
+                  "\n\n"
+                  "*** StylePtr<> error: Style must be a solid color, not transparent.\n");
+  }
 }
 
 // Usage: StylePtr<BLADE>
@@ -140,15 +148,10 @@ class ChargingStyle : public Style<T> {
 // Get a pointer to class.
 template<class STYLE>
 StyleAllocator StylePtr() {
-  using _TopBaseT  = typename style_base_check_detail::TopBase<STYLE>::type;
-  using _TopBaseCol = decltype(std::declval<_TopBaseT&>().getColor(0));
-  static_assert(color_details::IsOpaqueColor<_TopBaseCol>::value,
-                "\n\n"
-                "*** StylePtr<> error: BASE LAYER MUST BE A SOLID COLOR, NOT TRANSPARENT.\n"
-                "*** (No \"L\" layers allowed as base layer!)\n");
+  style_base_check_detail::AssertLayersBaseOpaque<STYLE>();
   static StyleFactoryImpl<Style<STYLE> > factory;
   return &factory;
-};
+}
 
 class StyleFactoryWithDefault : public StyleFactory {
 public:
@@ -177,12 +180,7 @@ StyleAllocator StylePtr(const char* default_arguments) {
 // that you can't turn it on/off, and the battery low warning is disabled.
 template<class STYLE>
 StyleAllocator ChargingStylePtr() {
-  using _TopBaseT  = typename style_base_check_detail::TopBase<STYLE>::type;
-  using _TopBaseCol = decltype(std::declval<_TopBaseT&>().getColor(0));
-  static_assert(color_details::IsOpaqueColor<_TopBaseCol>::value,
-                "\n\n"
-                "*** StylePtr<> error: BASE LAYER MUST BE A SOLID COLOR, NOT TRANSPARENT.\n"
-                "*** (No \"L\" layers allowed as base layer!)\n");
+  style_base_check_detail::AssertLayersBaseOpaque<STYLE>();
   static StyleFactoryImpl<ChargingStyle<STYLE> > factory;
   return &factory;
 }

From fa5fc5119827dd1b77eaf3f2094b05ae00e31f01 Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Mon, 18 Aug 2025 00:40:57 -0400
Subject: [PATCH 15/19] remove _BaseColorT

---
 styles/layers.h | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/styles/layers.h b/styles/layers.h
index 524430dc3..5e3521fa3 100644
--- a/styles/layers.h
+++ b/styles/layers.h
@@ -24,10 +24,7 @@
 template<class BASE, class L1>
 class Compose {
 public:
-  using _BaseColorT  = decltype(std::declval<BASE&>().getColor(0));
-  using _LayerColorT = decltype(std::declval<L1&>().getColor(0));
-  static_assert(!(color_details::IsOpaqueColor<_BaseColorT>::value &&
-                  color_details::IsOpaqueColor<_LayerColorT>::value),
+static_assert(!color_details::IsOpaqueColor<decltype(std::declval<L1&>().getColor(0))>::value,
                 "\n\n"
                 "*** Layers<> error: Only the base color may be solid.\n\n");
   LayerRunResult run(BladeBase* blade) {

From 2e64a610cdc5589023ed5f936b75254248138ca6 Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Mon, 18 Aug 2025 13:28:30 -0400
Subject: [PATCH 16/19] indention

---
 styles/layers.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/styles/layers.h b/styles/layers.h
index 5e3521fa3..a70a715ff 100644
--- a/styles/layers.h
+++ b/styles/layers.h
@@ -24,7 +24,7 @@
 template<class BASE, class L1>
 class Compose {
 public:
-static_assert(!color_details::IsOpaqueColor<decltype(std::declval<L1&>().getColor(0))>::value,
+  static_assert(!color_details::IsOpaqueColor<decltype(std::declval<L1&>().getColor(0))>::value,
                 "\n\n"
                 "*** Layers<> error: Only the base color may be solid.\n\n");
   LayerRunResult run(BladeBase* blade) {

From 848ce5e117098cbdf39dad90f3be94648a448541 Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Mon, 18 Aug 2025 13:55:20 -0400
Subject: [PATCH 17/19] remove redundant/incorrect Black specialization

---
 styles/layers.h | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/styles/layers.h b/styles/layers.h
index a70a715ff..f0867fb09 100644
--- a/styles/layers.h
+++ b/styles/layers.h
@@ -91,15 +91,6 @@ template<class BASE, class L1> struct LayerSelector<AlphaL<BASE, Int<0>>, L1> {
 template<class BASE, class ABASE>
 struct LayerSelector<BASE, AlphaL<ABASE, Int<0>>> { typedef BASE type; };
 
-// Drop BLACK when it’s first (two-arg case).
-template<class L1>
-struct LayerSelector<BLACK, L1> { typedef L1 type; };
-
-// Drop BLACK when it’s first (recursive case).
-template<class L1, class... REST>
-struct LayerSelector<BLACK, L1, REST...> {
-  typedef typename LayerSelector<L1, REST...>::type type;
-};
 template<class BASE, class L1> struct LayerSelector<BASE, L1> { typedef Compose<BASE, L1> type; };
 template<class BASE, class L1, class ... REST>
 struct LayerSelector<BASE, L1, REST...> {

From c87e436f3bef9781fd8bb2f888e7cab4e1a1e316 Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Sun, 24 Aug 2025 21:15:01 -0400
Subject: [PATCH 18/19] restore "Gimp" in description text.

---
 styles/layers.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/styles/layers.h b/styles/layers.h
index f0867fb09..b6db0a5cb 100644
--- a/styles/layers.h
+++ b/styles/layers.h
@@ -11,7 +11,7 @@
 // BASE: COLOR or LAYER
 // LAYER1, LAYER2: LAYER
 // return value: COLOR or LAYER (same as BASE)
-// This style works like layers in Photoshop: each layer adds to the stack covering the base. 
+// This style works like layers in Gimp or Photoshop: each layer adds to the stack covering the base.
 // The written order of layers in the blade style code puts the base first, with any following layers visually covering it.
 //
 // When a Layers<> is used as the first template argument to StylePtr<>, its BASE color (the first layer)

From df0155c7b5cddc45c44b4fa0f40933b40cf49c11 Mon Sep 17 00:00:00 2001
From: NoSloppy <53964195+NoSloppy@users.noreply.github.com>
Date: Sun, 24 Aug 2025 21:31:03 -0400
Subject: [PATCH 19/19] Update Usage

---
 styles/layers.h | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/styles/layers.h b/styles/layers.h
index b6db0a5cb..a165b28f4 100644
--- a/styles/layers.h
+++ b/styles/layers.h
@@ -11,15 +11,19 @@
 // BASE: COLOR or LAYER
 // LAYER1, LAYER2: LAYER
 // return value: COLOR or LAYER (same as BASE)
-// This style works like layers in Gimp or Photoshop: each layer adds to the stack covering the base.
-// The written order of layers in the blade style code puts the base first, with any following layers visually covering it.
+// This style works like layers in Gimp or Photoshop: each layer adds to the stack covering the BASE.
+// The written order of layers in the blade style code puts the BASE first,
+// with any following layers visually covering it. (later layers draw over earlier ones)
+// The rule for opacity is as follows:
+//   The output of Layers<> is opaque if the BASE of that Layers<> is opaque.
+//   If BASE is transparent: the overall result is transparent.
+//   No additional solid opaque colors may be stacked on top of an opaque BASE.
 //
-// When a Layers<> is used as the first template argument to StylePtr<>, its BASE color (the first layer)
-// must be a solid (opaque) color, not transparent. No additional solid colors may be stacked on top
-// of that solid base.
-// Additional layers stacked on top of a solid base color are transparent,
-// so the base color shows through until an effect wants to paint over it (e.g., a clash).
-// Layers<> can be nested inside other Layers<> and can be used anywhere a STYLE or COLOR is expected.
+// StylePtr<> expects its argument to be opaque.
+// Therefore, when using StylePtr<Layers<BASE, ... >>(), BASE MUST be an opaque color.
+//
+// Layers<> itself can still be nested anywhere a STYLE/COLOR is allowed; only the top-level StylePtr<...>()
+// requirement forces the requirement of the BASE to be opaque in that specific position.
 
 template<class BASE, class L1>
 class Compose {