@@ -945,6 +945,21 @@ not: a shadow pixel used to keep the entry belonging to the colour it had covere
 so `Serum_Rotate()` would animate the shadow with someone else's rotation. The
 replay stamps `0xffff`.
 
+Outside layer mode `CheckDynaShadow()` paints the shadow in place, and it sets
+the rotation entry of the pixel to `0xffff` with it. It did not before. The
+pixel loop skips a pixel a shadow has claimed, so such a pixel kept the entry an
+earlier frame had left there, or what the allocation held on the first frame
+after a load, and a shadow painted over a pixel already rendered kept that
+pixel's entry. `Serum_Rotate()` then animated the shadow: on `afm_113b` frames
+16 to 77 (white high-score digits over a sky whose stars rotate through white)
+the shadow under every digit ran through the stars' colours. This path is every
+`32p`-only request for a 32-row ROM, and the native plane of the other two
+layouts.
+
+**Rule: neither dynamic-zone content nor a dynamic shadow takes part in a colour
+rotation, even when its colour is one of the rotation's colours.** Both get the
+entry `0xffff`. Background, static and sprite pixels are looked up by colour.
+
 The offset is a persisted per-colorization choice, `shadowOffsetMode`:
 `SERUM_SHADOW_OFFSET_NATIVE` (1 extra-plane pixel — what the pre-layer renderer
 produced, and what authors tuned against) or `_PROPORTIONAL` (2 pixels, matching
 
@@ -5823,7 +5823,16 @@ static inline bool ColorInRotationOnPlane(bool planeRotates, uint32_t IDfound,
 // sdShadowColour. isdynapix is left alone in that case -- the pixel is not
 // dynamic content yet, and marking it would stop the static pass filling in
 // what the shadow sits on.
-void CheckDynaShadow(uint16_t* pfr, const uint8_t* shadowDirByLayer,
+//
+// prot: the per-pixel rotation entries of the plane pfr is. A shadow painted
+// here is a flat colour and takes no part in a rotation, so its entry is set
+// to 0xffff with it. The pixel loop does not do that: it skips a pixel a
+// shadow has claimed, so the entry kept what an earlier frame had put there,
+// or what the allocation held on the first frame, and Serum_Rotate() then
+// animated the shadow. A shadow painted over a pixel the loop had already
+// rendered kept that pixel's entry the same way.
+void CheckDynaShadow(uint16_t* pfr, uint16_t* prot,
+                     const uint8_t* shadowDirByLayer,
                      const uint16_t* shadowColorByLayer, uint8_t dynacouche,
                      uint8_t* isdynapix, uint16_t fx, uint16_t fy, uint32_t fw,
                      uint32_t fh, const uint8_t* shadowDirFallback = nullptr,
@@ -5857,6 +5866,10 @@ void CheckDynaShadow(uint16_t* pfr, const uint8_t* shadowDirByLayer,
     }
     isdynapix[neighborIndex] = 1;
     pfr[neighborIndex] = tcol;
+    if (prot) {
+      prot[neighborIndex * 2] = 0xffff;
+      prot[neighborIndex * 2 + 1] = 0xffff;
+    }
   }
 }
 
@@ -6068,7 +6081,7 @@ void Colorize_Framev2(uint8_t* frame, uint32_t IDfound,
                 // picture the upscale reads has to be shadow-free for that to
                 // mean anything. ReplayOriginalPlaneShadows() puts it back
                 // afterwards for the 32p output.
-                CheckDynaShadow(pfr, frameShadowDir, frameShadowColor,
+                CheckDynaShadow(pfr, prot, frameShadowDir, frameShadowColor,
                                 dynacouche, isdynapix, ti, tj,
                                 g_serumData.fwidth, g_serumData.fheight,
                                 shadowDirFallback, shadowColorFallback,
@@ -6279,9 +6292,9 @@ void Colorize_Framev2(uint8_t* frame, uint32_t IDfound,
                 }
               }
               if (!dynamicBlackSuppressed) {
-                CheckDynaShadow(pfr, frameShadowDirExtra, frameShadowColorExtra,
-                                dynacouche, isdynapix, ti, tj,
-                                g_serumData.fwidth_extra,
+                CheckDynaShadow(pfr, prot, frameShadowDirExtra,
+                                frameShadowColorExtra, dynacouche, isdynapix,
+                                ti, tj, g_serumData.fwidth_extra,
                                 g_serumData.fheight_extra);
                 isdynapix[tk] = 1;
                 pfr[tk] = dynamicColor;
 
@@ -120,6 +120,9 @@ and a packing bug corrupts every colorization at once.
 | `rotation/advances_tagged_pixels_only` | a pixel tagged with a slot advances, a pixel tagged `0xffff` never does |
 | `rotation/wraps_at_length` | the shift wraps at the rotation's length instead of running off its colour list |
 | `rotation/empty_slot_not_due_next` | a slot with no colours or no delay is not a rotation and is not reported as due |
+| `rotation/dynamic_content_and_shadow_32p` | a dynamic pixel in a rotation's colour and the shadow it casts, above and below, have the entry `0xffff` and stand still while the background rotates; without the `0xffff` in `CheckDynaShadow()` the shadow keeps an old entry and rotates |
+| `rotation/dynamic_content_and_shadow_64p` | the same on the upscaled plane for a `64P`-only request |
+| `rotation/dynamic_content_and_shadow_both` | and for `32P \| 64P`, on both planes |
 
 ### `is256x64` projects
 
 
@@ -505,8 +505,9 @@ static void Test_DeferredShadowLeavesThePlaneAlone(void) {
   std::vector<uint8_t> isdynapix((size_t)kW * kH, 0);
   mySerum.frame32[(size_t)6 * kW + 5] = 0xABCD;  // what the shadow will cover
 
-  CheckDynaShadow(mySerum.frame32, dir.data(), col.data(), 0, isdynapix.data(),
-                  5, 5, kW, kH, nullptr, nullptr, /*defer=*/true);
+  CheckDynaShadow(mySerum.frame32, mySerum.rotationsinframe32, dir.data(),
+                  col.data(), 0, isdynapix.data(), 5, 5, kW, kH, nullptr,
+                  nullptr, /*defer=*/true);
 
   const size_t below = (size_t)6 * kW + 5;
   CHECK_EQ(mySerum.frame32[below], 0xABCD);  // untouched, so it can be scaled
@@ -2041,6 +2042,175 @@ static void Test_EmptyRotationSlotIsNotDueNext(void) {
   TearDownFrame();
 }
 
+// ---------------------------------------------------------------------------
+// Rotations and dynamic content
+//
+// A rotating background (stars) under a dynamic zone whose glyph has a colour
+// that is one of the rotation's colours, and a dynamic shadow above and below
+// the glyph. Only the background moves: dynamic content is coloured from its
+// set and a shadow is a flat colour, whatever colours the frame's rotations
+// name. afm_113b frames 16 to 77 are this picture: white high-score digits
+// over a sky whose stars rotate through white.
+// ---------------------------------------------------------------------------
+
+static const uint16_t kStarA = 0x0222, kStarB = 0x0333;  // the rotation
+static const uint16_t kGlyphShadow = 0x0444;
+static const uint32_t kGlyphX = 5, kGlyphY = 6;
+static const uint32_t kStarX = 20, kStarY = 20;  // background, far from it
+
+enum RotationRequest { kRequest32, kRequest64, kRequestBoth };
+
+static void RenderGlyphOverRotatingBackground(RotationRequest request) {
+  SetUpColorization();
+  const size_t px = (size_t)kW * kCH;
+  const std::vector<uint16_t> bg(px, kStarA);
+  g_serumData.backgroundframes_v2.set(0, bg.data(), px);
+  const std::vector<uint8_t> mask(px, 1);
+  g_serumData.backgroundmask.set(kFrameId, mask.data(), px);
+  const uint16_t background[1] = {0};
+  g_serumData.backgroundIDs.set(kFrameId, background, 1);
+
+  // A 3x3 zone, lit in the middle only; the glyph takes the rotation's
+  // second colour from its set.
+  std::vector<uint8_t> active(px, 0);
+  for (uint32_t y = kGlyphY - 1; y <= kGlyphY + 1; ++y)
+    for (uint32_t x = kGlyphX - 1; x <= kGlyphX + 1; ++x)
+      active[(size_t)y * kW + x] = 1;
+  std::vector<uint16_t> shadeToColour(16, 0);
+  shadeToColour[5] = kStarB;
+  GiveFrameADynamicZone(active, /*couche=*/0, shadeToColour);
+  std::vector<uint8_t> dir(MAX_DYNA_SETS_PER_FRAME_V2, 0);
+  std::vector<uint16_t> col(MAX_DYNA_SETS_PER_FRAME_V2, 0);
+  // Above, a pixel the raster has rendered already, and below, one it has
+  // not reached yet.
+  dir[0] = (1u << 1) | (1u << 5);
+  col[0] = kGlyphShadow;
+  g_serumData.dynashadowsdir.set(kFrameId, dir.data(), dir.size());
+  g_serumData.dynashadowscol.set(kFrameId, col.data(), col.size());
+
+  const size_t tableSize = MAX_COLOR_ROTATION_V2 * MAX_LENGTH_COLOR_ROTATION;
+  std::vector<uint16_t> table(tableSize, 0);
+  table[0] = 2;   // two colours
+  table[1] = 10;  // every 10 ms
+  table[2] = kStarA;
+  table[3] = kStarB;
+  g_serumData.colorrotations_v2.reserve(tableSize);
+  g_serumData.colorrotations_v2_extra.reserve(tableSize);
+  g_serumData.colorrotations_v2.set(kFrameId, table.data(), tableSize);
+  g_serumData.BuildColorRotationLookup();
+  mySerum.rotations32 = (uint16_t*)calloc(tableSize, sizeof(uint16_t));
+  mySerum.rotations64 = (uint16_t*)calloc(tableSize, sizeof(uint16_t));
+  memcpy(mySerum.rotations32, table.data(), tableSize * sizeof(uint16_t));
+  memcpy(mySerum.rotations64, table.data(), tableSize * sizeof(uint16_t));
+
+  upscaleExtraFromOriginal = request != kRequest32;
+  originalPlaneRequestedByCaller = request != kRequest64;
+  // What an earlier frame left behind, or the allocation on the first frame:
+  // an entry nothing writes would name slot 0.
+  memset(mySerum.rotationsinframe32, 0, px * 2 * sizeof(uint16_t));
+  memset(mySerum.rotationsinframe64, 0, px * 8 * sizeof(uint16_t));
+  memset(colorshifts32, 0, sizeof(colorshifts32));
+  memset(colorshifts64, 0, sizeof(colorshifts64));
+
+  g_rom.assign(px, 0);
+  g_rom[(size_t)kGlyphY * kW + kGlyphX] = 5;
+  romFrameForUpscale = g_rom.data();
+  Colorize_Framev2(g_rom.data(), kFrameId);
+}
+
+// One rotation step on both planes, however long ago the last one was.
+static void StepGlyphRotation(void) {
+  colorshiftinittime32[0] = 0;
+  colorshiftinittime64[0] = 0;
+  Serum_ApplyRotationsv2();
+}
+
+static void Test_DynamicContentAndItsShadowDoNotRotate32(void) {
+  RenderGlyphOverRotatingBackground(kRequest32);
+  CHECK(mySerum.flags & FLAG_RETURNED_32P_FRAME_OK);
+  const size_t glyph = (size_t)kGlyphY * kW + kGlyphX;
+  const size_t above = glyph - kW, below = glyph + kW;
+  const size_t star = (size_t)kStarY * kW + kStarX;
+  CHECK_EQ(mySerum.frame32[glyph], kStarB);
+  CHECK_EQ(mySerum.frame32[above], kGlyphShadow);
+  CHECK_EQ(mySerum.frame32[below], kGlyphShadow);
+  CHECK_EQ(mySerum.frame32[star], kStarA);
+  CHECK_EQ(mySerum.rotationsinframe32[glyph * 2], 0xffff);
+  CHECK_EQ(mySerum.rotationsinframe32[above * 2], 0xffff);
+  CHECK_EQ(mySerum.rotationsinframe32[above * 2 + 1], 0xffff);
+  CHECK_EQ(mySerum.rotationsinframe32[below * 2], 0xffff);
+  CHECK_EQ(mySerum.rotationsinframe32[below * 2 + 1], 0xffff);
+  CHECK_EQ(mySerum.rotationsinframe32[star * 2], 0);
+  // Every pixel is either the background, in the rotation, or not in one.
+  const size_t px = (size_t)kW * kCH;
+  unsigned rotating = 0;
+  for (size_t i = 0; i < px; ++i)
+    if (mySerum.rotationsinframe32[i * 2] != 0xffff) ++rotating;
+  CHECK_EQ(rotating, px - 3);
+
+  for (int step = 1; step <= 4; ++step) {
+    StepGlyphRotation();
+    CHECK_EQ(mySerum.frame32[glyph], kStarB);
+    CHECK_EQ(mySerum.frame32[above], kGlyphShadow);
+    CHECK_EQ(mySerum.frame32[below], kGlyphShadow);
+    CHECK_EQ(mySerum.frame32[star], (step & 1) ? kStarB : kStarA);
+  }
+  TearDownFrame();
+}
+
+// The upscaled plane, for a caller that asked for it alone and for one that
+// asked for both: the glyph's 2x2 block and the shadows generated around it
+// stand still while the background behind them rotates.
+static void CheckUpscaledGlyphDoesNotRotate(RotationRequest request) {
+  RenderGlyphOverRotatingBackground(request);
+  CHECK(mySerum.flags & FLAG_RETURNED_64P_FRAME_OK);
+  const uint32_t w = kW * 2;
+  const size_t px = (size_t)w * kCH * 2;
+  const std::vector<uint16_t> first(mySerum.frame64, mySerum.frame64 + px);
+  unsigned glyph = 0, shadow = 0;
+  for (size_t i = 0; i < px; ++i) {
+    if (first[i] == kStarA) {
+      CHECK_EQ(mySerum.rotationsinframe64[i * 2], 0);
+      continue;
+    }
+    // Not the background: the glyph, a shadow, or a frame corner the
+    // upscale rounded away.
+    if (first[i] == kStarB) ++glyph;
+    if (first[i] == kGlyphShadow) ++shadow;
+    CHECK_EQ(mySerum.rotationsinframe64[i * 2], 0xffff);
+  }
+  CHECK_EQ(glyph, 4);
+  CHECK(shadow > 0);
+  CHECK_EQ(first[(size_t)(kGlyphY * 2) * w + kGlyphX * 2], kStarB);
+
+  for (int step = 1; step <= 4; ++step) {
+    StepGlyphRotation();
+    for (size_t i = 0; i < px; ++i) {
+      if (first[i] == kStarA)
+        CHECK_EQ(mySerum.frame64[i], (step & 1) ? kStarB : kStarA);
+      else
+        CHECK_EQ(mySerum.frame64[i], first[i]);
+    }
+    if (request == kRequestBoth) {
+      const size_t at = (size_t)kGlyphY * kW + kGlyphX;
+      CHECK_EQ(mySerum.frame32[at], kStarB);
+      CHECK_EQ(mySerum.frame32[at - kW], kGlyphShadow);
+      CHECK_EQ(mySerum.frame32[at + kW], kGlyphShadow);
+      CHECK_EQ(mySerum.frame32[(size_t)kStarY * kW + kStarX],
+               (step & 1) ? kStarB : kStarA);
+    }
+  }
+  TearDownFrame();
+}
+
+static void Test_DynamicContentAndItsShadowDoNotRotate64(void) {
+  CheckUpscaledGlyphDoesNotRotate(kRequest64);
+}
+
+static void Test_DynamicContentAndItsShadowDoNotRotateBoth(void) {
+  CheckUpscaledGlyphDoesNotRotate(kRequestBoth);
+}
+
 // ---------------------------------------------------------------------------
 // is256x64 projects
 //
@@ -3837,6 +4007,12 @@ static const TestCase kTests[] = {
      Test_RotationAdvancesTaggedPixelsOnly},
     {"rotation/wraps_at_length", Test_RotationWrapsAtItsLength},
     {"rotation/empty_slot_not_due_next", Test_EmptyRotationSlotIsNotDueNext},
+    {"rotation/dynamic_content_and_shadow_32p",
+     Test_DynamicContentAndItsShadowDoNotRotate32},
+    {"rotation/dynamic_content_and_shadow_64p",
+     Test_DynamicContentAndItsShadowDoNotRotate64},
+    {"rotation/dynamic_content_and_shadow_both",
+     Test_DynamicContentAndItsShadowDoNotRotateBoth},
     {"n256/loads_and_forgets", Test_N256LoadsAndForgets},
     {"n256/rejects_other_geometry", Test_N256RejectsOtherGeometry},
     {"n256/identification", Test_N256Identification},