From a8ae7059a28e991ccbdf9e6eb6c5c994842c6fff Mon Sep 17 00:00:00 2001
From: aeoa <64489515+aeoa@users.noreply.github.com>
Date: Wed, 3 Jun 2026 22:02:54 +0200
Subject: [PATCH 1/8] Add clocked playlist scheduling

---
 wled00/const.h       |   1 +
 wled00/data/index.js |  32 +++++++++++++-
 wled00/playlist.cpp  | 103 +++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 134 insertions(+), 2 deletions(-)

diff --git a/wled00/const.h b/wled00/const.h
index 70373316fd..f5e431928e 100644
--- a/wled00/const.h
+++ b/wled00/const.h
@@ -448,6 +448,7 @@ static_assert(WLED_MAX_BUSSES <= 32, "WLED_MAX_BUSSES exceeds hard limit");
 //Playlist option byte
 #define PL_OPTION_SHUFFLE      0x01
 #define PL_OPTION_RESTORE      0x02
+#define PL_OPTION_CLOCKED      0x04
 
 // Segment capability byte
 #define SEG_CAPABILITY_RGB     0x01
diff --git a/wled00/data/index.js b/wled00/data/index.js
index ee5126973c..4de8b99c0f 100644
--- a/wled00/data/index.js
+++ b/wled00/data/index.js
@@ -2008,6 +2008,7 @@ function plR(p)
 {
 	var pl = plJson[p];
 	pl.r = gId(`pl${p}rtgl`).checked;
+	pl.clocked = gId(`pl${p}clocked`).checked;
 	if (gId(`pl${p}rptgl`).checked) { // infinite
 		pl.repeat = 0;
 		delete pl.end;
@@ -2019,6 +2020,25 @@ function plR(p)
 	}
 }
 
+function plClock(p)
+{
+	const clocked = gId(`pl${p}clocked`).checked;
+	const manual = gId(`pl${p}manual`);
+	if (clocked && manual.checked) {
+		manual.checked = false;
+		plM(p);
+	} else if (clocked) {
+		plJson[p].dur.forEach((e,i)=>{
+			if (e > 0) return;
+			plJson[p].dur[i] = 100;
+			const d = gId(`pl${p}du${i}`);
+			if (d) d.value = 10;
+		});
+	}
+	manual.disabled = clocked;
+	plR(p);
+}
+
 function plM(p)
 {
 	const man = gId(`pl${p}manual`).checked;
@@ -2041,17 +2061,24 @@ function makeP(i,pl)
 			transition: [tr],
 			repeat: 0,
 			r: false,
+			clocked: false,
 			end: 0
 		};
 		const rep = plJson[i].repeat ? plJson[i].repeat : 0;
-		const man = plJson[i].dur == 0;
+		const clocked = !!plJson[i].clocked;
+		if (clocked) plJson[i].dur = plJson[i].dur.map(d => d > 0 ? d : 100);
+		const man = !clocked && plJson[i].dur.every(d => d == 0);
 		content =
 `<div id="ple${i}" style="margin-top:10px;"></div><label class="check revchkl">Shuffle
 	<input type="checkbox" id="pl${i}rtgl" onchange="plR(${i})" ${plJson[i].r||rep<0?"checked":""}>
 	<span class="checkmark"></span>
 </label>
+<label class="check revchkl">Clock sync
+	<input type="checkbox" id="pl${i}clocked" onchange="plClock(${i})" ${clocked?"checked":""}>
+	<span class="checkmark"></span>
+</label>
 <label class="check revchkl">Manual advance
-	<input type="checkbox" id="pl${i}manual" onchange="plM(${i})" ${man?"checked":""}>
+	<input type="checkbox" id="pl${i}manual" onchange="plM(${i})" ${man?"checked":""} ${clocked?"disabled":""}>
 	<span class="checkmark"></span>
 </label>
 <label class="check revchkl">Repeat indefinitely
@@ -3050,6 +3077,7 @@ function expand(i)
 				formatArr(plJson[p]);
 				if (isNaN(plJson[p].repeat)) plJson[p].repeat = 0;
 				if (!plJson[p].r) plJson[p].r = false;
+				if (!plJson[p].clocked) plJson[p].clocked = false;
 				if (isNaN(plJson[p].end)) plJson[p].end = 0;
 				gId('seg' +i).innerHTML = makeP(p,true);
 				refreshPlE(p);
diff --git a/wled00/playlist.cpp b/wled00/playlist.cpp
index c5acecdaf1..07ebe4ebee 100644
--- a/wled00/playlist.cpp
+++ b/wled00/playlist.cpp
@@ -18,6 +18,7 @@ static PlaylistEntry *playlistEntries = nullptr;
 static byte           playlistLen;               //number of playlist entries
 static int8_t         playlistIndex = -1;
 static uint32_t       playlistEntryDur = 0;      //duration of the current entry in milliseconds
+static bool           clockedPlaylistSynced = false;
 
 //values we need to keep about the parent playlist while inside sub-playlist
 static int16_t        parentPlaylistIndex = -1;
@@ -41,6 +42,24 @@ void shufflePlaylist() {
   DEBUG_PRINTLN(F("Playlist shuffle."));
 }
 
+// AI: below section was generated by an AI
+static uint32_t playlistShuffleRand(uint32_t &state) {
+  state ^= state << 13;
+  state ^= state >> 17;
+  state ^= state << 5;
+  return state;
+}
+
+static uint32_t clockedPlaylistSeed(uint32_t cycle) {
+  uint32_t seed = 2166136261UL;
+  seed = (seed ^ (uint32_t)currentPlaylist) * 16777619UL;
+  seed = (seed ^ cycle) * 16777619UL;
+  seed = (seed ^ playlistLen) * 16777619UL;
+  if (seed == 0) seed = 2166136261UL;
+  return seed;
+}
+// AI: end
+
 
 void unloadPlaylist() {
   if (playlistEntries != nullptr) {
@@ -51,9 +70,58 @@ void unloadPlaylist() {
   playlistLen = 0;
   playlistOptions = 0;
   playlistEntryDur = 0;
+  clockedPlaylistSynced = false;
   DEBUG_PRINTLN(F("Playlist unloaded."));
 }
 
+// AI: below section was generated by an AI
+static bool getClockedPlaylistState(uint8_t &entryIndex, uint32_t &entryOffset) {
+  if (!(playlistOptions & PL_OPTION_CLOCKED) || playlistLen == 0 || playlistEntries == nullptr) return false;
+  if (toki.getTimeSource() == TOKI_TS_NONE) return false;
+
+  // Clocked playlists live on an absolute Toki timeline; every entry must have finite duration.
+  uint64_t cycleDur = 0;
+  for (byte i = 0; i < playlistLen; i++) {
+    if (playlistEntries[i].dur == 0) return false; // infinite entries cannot be placed on a repeating wall-clock timeline
+    cycleDur += playlistEntries[i].dur;
+  }
+  if (cycleDur == 0) return false;
+
+  Toki::Time tm = toki.getTime();
+  uint64_t absoluteMs = (uint64_t)tm.sec * 1000ULL + tm.ms;
+  uint32_t cycle = (uint32_t)(absoluteMs / cycleDur);
+  uint64_t cycleOffset = absoluteMs % cycleDur;
+
+  uint8_t order[100];
+  for (byte i = 0; i < playlistLen; i++) order[i] = i;
+  if (playlistOptions & PL_OPTION_SHUFFLE) {
+    // Keep shuffle deterministic for all controllers within the same wall-clock cycle.
+    uint32_t seed = clockedPlaylistSeed(cycle);
+    for (int i = playlistLen - 1; i > 0; i--) {
+      int j = playlistShuffleRand(seed) % (i + 1);
+      uint8_t tmp = order[i];
+      order[i] = order[j];
+      order[j] = tmp;
+    }
+  }
+
+  for (byte i = 0; i < playlistLen; i++) {
+    uint8_t orderedIndex = order[i];
+    uint32_t dur = playlistEntries[orderedIndex].dur;
+    if (cycleOffset < dur) {
+      entryIndex = orderedIndex;
+      entryOffset = (uint32_t)cycleOffset;
+      return true;
+    }
+    cycleOffset -= dur;
+  }
+
+  entryIndex = order[playlistLen - 1];
+  entryOffset = playlistEntries[entryIndex].dur - 1;
+  return true;
+}
+// AI: end
+
 
 int16_t loadPlaylist(JsonObject playlistObj, byte presetId) {
   if (currentPlaylist > 0 && parentPlaylistPresetId > 0) return -1; // we are already in nested playlist, do nothing
@@ -127,6 +195,7 @@ int16_t loadPlaylist(JsonObject playlistObj, byte presetId) {
   }
   if (playlistEndPreset > 250) playlistEndPreset = 0;
   shuffle = shuffle || playlistObj["r"];
+  if (playlistObj[F("clocked")] | false) playlistOptions |= PL_OPTION_CLOCKED;
   if (shuffle) playlistOptions |= PL_OPTION_SHUFFLE;
 
   if (parentPlaylistPresetId == 0 && parentPlaylistIndex > -1) {
@@ -152,6 +221,39 @@ void handlePlaylist() {
   static unsigned long presetCycledTime = 0;
   if (currentPlaylist < 0 || playlistEntries == nullptr) return;
 
+  if (playlistOptions & PL_OPTION_CLOCKED) {
+    if (toki.getTimeSource() == TOKI_TS_NONE) {
+      if (playlistIndex < 0 && !nightlightActive) {
+        playlistIndex = 0;
+        jsonTransitionOnce = true;
+        strip.setTransition(playlistEntries[playlistIndex].tr * 100);
+        playlistEntryDur = playlistEntries[playlistIndex].dur > 0 ? playlistEntries[playlistIndex].dur : UINT32_MAX;
+        strip.resetTimebase();
+        applyPresetFromPlaylist(playlistEntries[playlistIndex].preset);
+      }
+      return;
+    }
+
+    uint8_t derivedIndex = 0;
+    uint32_t entryOffset = 0;
+    if (!getClockedPlaylistState(derivedIndex, entryOffset)) return;
+
+    if (nightlightActive) return;
+
+    strip.timebase = (unsigned long)entryOffset - millis();
+
+    if (!clockedPlaylistSynced || playlistIndex != (int8_t)derivedIndex) {
+      playlistIndex = derivedIndex;
+      jsonTransitionOnce = true;
+      strip.setTransition(playlistEntries[playlistIndex].tr * 100);
+      playlistEntryDur = playlistEntries[playlistIndex].dur;
+      applyPresetFromPlaylist(playlistEntries[playlistIndex].preset);
+    }
+    clockedPlaylistSynced = true;
+    doAdvancePlaylist = false;
+    return;
+  }
+
   if ((playlistEntryDur < UINT32_MAX && millis() - presetCycledTime > playlistEntryDur) || doAdvancePlaylist) {
     presetCycledTime = millis();
     if (bri == 0 || nightlightActive) return;
@@ -190,6 +292,7 @@ void serializePlaylist(JsonObject sObj) {
   playlist[F("repeat")] = (playlistIndex < 0 && playlistRepeat > 0) ? playlistRepeat - 1 : playlistRepeat; // remove added repetition count (if not yet running)
   playlist["end"] = playlistOptions & PL_OPTION_RESTORE ? 255 : playlistEndPreset;
   playlist["r"] = playlistOptions & PL_OPTION_SHUFFLE;
+  playlist[F("clocked")] = (playlistOptions & PL_OPTION_CLOCKED) != 0;
   for (int i=0; i<playlistLen; i++) {
     ps.add(playlistEntries[i].preset);
     dur.add((playlistEntries[i].dur) / 100); // convert ms back to tenths of seconds (backwards compatibility)

From 976262964dfac86bdff4a4d9688233c6f5373eee Mon Sep 17 00:00:00 2001
From: aeoa <64489515+aeoa@users.noreply.github.com>
Date: Wed, 3 Jun 2026 22:40:25 +0200
Subject: [PATCH 2/8] Handle zero-duration clocked playlist entries

---
 wled00/playlist.cpp | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/wled00/playlist.cpp b/wled00/playlist.cpp
index 07ebe4ebee..a35ef7bab4 100644
--- a/wled00/playlist.cpp
+++ b/wled00/playlist.cpp
@@ -43,6 +43,13 @@ void shufflePlaylist() {
 }
 
 // AI: below section was generated by an AI
+static const uint32_t CLOCKED_PLAYLIST_DEFAULT_DUR = 10000UL;
+
+static uint32_t normalizeClockedPlaylistDuration(uint32_t durMs, uint32_t fallbackDur) {
+  if (durMs > 0) return durMs;
+  return fallbackDur > 0 ? fallbackDur : CLOCKED_PLAYLIST_DEFAULT_DUR;
+}
+
 static uint32_t playlistShuffleRand(uint32_t &state) {
   state ^= state << 13;
   state ^= state >> 17;
@@ -136,6 +143,7 @@ int16_t loadPlaylist(JsonObject playlistObj, byte presetId) {
   playlistLen = presets.size();
   if (playlistLen == 0) return -1;
   if (playlistLen > 100) playlistLen = 100;
+  bool clocked = playlistObj[F("clocked")] | false;
 
   playlistEntries = new(std::nothrow) PlaylistEntry[playlistLen];
   if (playlistEntries == nullptr) return -1;
@@ -152,13 +160,17 @@ int16_t loadPlaylist(JsonObject playlistObj, byte presetId) {
   if (durations.isNull()) {
     uint32_t durMs = playlistObj["dur"] | 100; // 10 seconds as fallback (tenths)
     durMs = constrain(durMs, 0L, 42949670L) * 100UL; // limit to max value and convert to ms
+    if (clocked) durMs = normalizeClockedPlaylistDuration(durMs, CLOCKED_PLAYLIST_DEFAULT_DUR);
     playlistEntries[0].dur = (uint32_t)durMs;
     it = 1;
   } else {
+    uint32_t fallbackDur = CLOCKED_PLAYLIST_DEFAULT_DUR;
     for (int dur : durations) {
       if (it >= playlistLen) break;
       uint32_t durMs = constrain(dur, 0L, 42949670L) * 100UL; // limit to max value and convert to ms
+      if (clocked) durMs = normalizeClockedPlaylistDuration(durMs, fallbackDur);
       playlistEntries[it].dur = (uint32_t)durMs;
+      fallbackDur = durMs;
       it++;
     }
   }
@@ -195,7 +207,7 @@ int16_t loadPlaylist(JsonObject playlistObj, byte presetId) {
   }
   if (playlistEndPreset > 250) playlistEndPreset = 0;
   shuffle = shuffle || playlistObj["r"];
-  if (playlistObj[F("clocked")] | false) playlistOptions |= PL_OPTION_CLOCKED;
+  if (clocked) playlistOptions |= PL_OPTION_CLOCKED;
   if (shuffle) playlistOptions |= PL_OPTION_SHUFFLE;
 
   if (parentPlaylistPresetId == 0 && parentPlaylistIndex > -1) {

From 5d3853872181f79dd1fb792cb18234abc04d6f8a Mon Sep 17 00:00:00 2001
From: aeoa <64489515+aeoa@users.noreply.github.com>
Date: Wed, 3 Jun 2026 22:51:17 +0200
Subject: [PATCH 3/8] Lock repeat controls for clocked playlists

---
 wled00/data/index.js | 23 ++++++++++++++++++-----
 1 file changed, 18 insertions(+), 5 deletions(-)

diff --git a/wled00/data/index.js b/wled00/data/index.js
index 4de8b99c0f..70978710ba 100644
--- a/wled00/data/index.js
+++ b/wled00/data/index.js
@@ -2007,9 +2007,16 @@ function pleTr(p,i,field)
 function plR(p)
 {
 	var pl = plJson[p];
+	const clocked = gId(`pl${p}clocked`);
+	const manual = gId(`pl${p}manual`);
+	const repeat = gId(`pl${p}rptgl`);
+	if (clocked.checked && !repeat.checked) {
+		clocked.checked = false;
+		manual.disabled = false;
+	}
 	pl.r = gId(`pl${p}rtgl`).checked;
-	pl.clocked = gId(`pl${p}clocked`).checked;
-	if (gId(`pl${p}rptgl`).checked) { // infinite
+	pl.clocked = clocked.checked;
+	if (repeat.checked) { // infinite
 		pl.repeat = 0;
 		delete pl.end;
 		gId(`pl${p}o1`).style.display = "none";
@@ -2024,6 +2031,7 @@ function plClock(p)
 {
 	const clocked = gId(`pl${p}clocked`).checked;
 	const manual = gId(`pl${p}manual`);
+	const repeat = gId(`pl${p}rptgl`);
 	if (clocked && manual.checked) {
 		manual.checked = false;
 		plM(p);
@@ -2035,6 +2043,7 @@ function plClock(p)
 			if (d) d.value = 10;
 		});
 	}
+	if (clocked && repeat) repeat.checked = true;
 	manual.disabled = clocked;
 	plR(p);
 }
@@ -2064,16 +2073,20 @@ function makeP(i,pl)
 			clocked: false,
 			end: 0
 		};
-		const rep = plJson[i].repeat ? plJson[i].repeat : 0;
 		const clocked = !!plJson[i].clocked;
-		if (clocked) plJson[i].dur = plJson[i].dur.map(d => d > 0 ? d : 100);
+		if (clocked) {
+			plJson[i].repeat = 0;
+			delete plJson[i].end;
+			plJson[i].dur = plJson[i].dur.map(d => d > 0 ? d : 100);
+		}
+		const rep = plJson[i].repeat ? plJson[i].repeat : 0;
 		const man = !clocked && plJson[i].dur.every(d => d == 0);
 		content =
 `<div id="ple${i}" style="margin-top:10px;"></div><label class="check revchkl">Shuffle
 	<input type="checkbox" id="pl${i}rtgl" onchange="plR(${i})" ${plJson[i].r||rep<0?"checked":""}>
 	<span class="checkmark"></span>
 </label>
-<label class="check revchkl">Clock sync
+<label class="check revchkl" title="Uses synced time; repeats indefinitely">Clock sync
 	<input type="checkbox" id="pl${i}clocked" onchange="plClock(${i})" ${clocked?"checked":""}>
 	<span class="checkmark"></span>
 </label>

From e72e248b8f4459913cded9caa71f1418a44bdff3 Mon Sep 17 00:00:00 2001
From: aeoa <64489515+aeoa@users.noreply.github.com>
Date: Thu, 4 Jun 2026 11:50:35 +0200
Subject: [PATCH 4/8] Refactor playlist entry activation

---
 wled00/playlist.cpp | 68 +++++++++++++++++++++++----------------------
 1 file changed, 35 insertions(+), 33 deletions(-)

diff --git a/wled00/playlist.cpp b/wled00/playlist.cpp
index a35ef7bab4..f924a0faaa 100644
--- a/wled00/playlist.cpp
+++ b/wled00/playlist.cpp
@@ -65,6 +65,14 @@ static uint32_t clockedPlaylistSeed(uint32_t cycle) {
   if (seed == 0) seed = 2166136261UL;
   return seed;
 }
+
+static void applyPlaylistEntry(uint8_t index, uint32_t durMs) {
+  playlistIndex = index;
+  jsonTransitionOnce = true;
+  strip.setTransition(playlistEntries[index].tr * 100);
+  playlistEntryDur = durMs;
+  applyPresetFromPlaylist(playlistEntries[index].preset);
+}
 // AI: end
 
 
@@ -127,6 +135,30 @@ static bool getClockedPlaylistState(uint8_t &entryIndex, uint32_t &entryOffset)
   entryOffset = playlistEntries[entryIndex].dur - 1;
   return true;
 }
+
+static void handleClockedPlaylist() {
+  if (toki.getTimeSource() == TOKI_TS_NONE) {
+    if (playlistIndex < 0 && !nightlightActive) {
+      strip.resetTimebase();
+      uint32_t durMs = playlistEntries[0].dur > 0 ? playlistEntries[0].dur : UINT32_MAX;
+      applyPlaylistEntry(0, durMs);
+    }
+    return;
+  }
+
+  uint8_t derivedIndex = 0;
+  uint32_t entryOffset = 0;
+  if (!getClockedPlaylistState(derivedIndex, entryOffset)) return;
+  if (nightlightActive) return;
+
+  strip.timebase = (unsigned long)entryOffset - millis();
+
+  if (!clockedPlaylistSynced || playlistIndex != (int8_t)derivedIndex) {
+    applyPlaylistEntry(derivedIndex, playlistEntries[derivedIndex].dur);
+  }
+  clockedPlaylistSynced = true;
+  doAdvancePlaylist = false;
+}
 // AI: end
 
 
@@ -234,35 +266,7 @@ void handlePlaylist() {
   if (currentPlaylist < 0 || playlistEntries == nullptr) return;
 
   if (playlistOptions & PL_OPTION_CLOCKED) {
-    if (toki.getTimeSource() == TOKI_TS_NONE) {
-      if (playlistIndex < 0 && !nightlightActive) {
-        playlistIndex = 0;
-        jsonTransitionOnce = true;
-        strip.setTransition(playlistEntries[playlistIndex].tr * 100);
-        playlistEntryDur = playlistEntries[playlistIndex].dur > 0 ? playlistEntries[playlistIndex].dur : UINT32_MAX;
-        strip.resetTimebase();
-        applyPresetFromPlaylist(playlistEntries[playlistIndex].preset);
-      }
-      return;
-    }
-
-    uint8_t derivedIndex = 0;
-    uint32_t entryOffset = 0;
-    if (!getClockedPlaylistState(derivedIndex, entryOffset)) return;
-
-    if (nightlightActive) return;
-
-    strip.timebase = (unsigned long)entryOffset - millis();
-
-    if (!clockedPlaylistSynced || playlistIndex != (int8_t)derivedIndex) {
-      playlistIndex = derivedIndex;
-      jsonTransitionOnce = true;
-      strip.setTransition(playlistEntries[playlistIndex].tr * 100);
-      playlistEntryDur = playlistEntries[playlistIndex].dur;
-      applyPresetFromPlaylist(playlistEntries[playlistIndex].preset);
-    }
-    clockedPlaylistSynced = true;
-    doAdvancePlaylist = false;
+    handleClockedPlaylist();
     return;
   }
 
@@ -287,10 +291,8 @@ void handlePlaylist() {
       if (playlistOptions & PL_OPTION_SHUFFLE) shufflePlaylist(); // shuffle playlist and start over
     }
 
-    jsonTransitionOnce = true;
-    strip.setTransition(playlistEntries[playlistIndex].tr * 100);
-    playlistEntryDur = playlistEntries[playlistIndex].dur > 0 ? playlistEntries[playlistIndex].dur : UINT32_MAX; // UINT32_MAX means infinite
-    applyPresetFromPlaylist(playlistEntries[playlistIndex].preset);
+    uint32_t durMs = playlistEntries[playlistIndex].dur > 0 ? playlistEntries[playlistIndex].dur : UINT32_MAX; // UINT32_MAX means infinite
+    applyPlaylistEntry(playlistIndex, durMs);
     doAdvancePlaylist = false;
   }
 }

From 884b517364ccdbb3db6091774970f424b1748d7d Mon Sep 17 00:00:00 2001
From: aeoa <64489515+aeoa@users.noreply.github.com>
Date: Thu, 4 Jun 2026 12:35:57 +0200
Subject: [PATCH 5/8] Use PRNG for clocked playlist shuffle

---
 wled00/playlist.cpp | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/wled00/playlist.cpp b/wled00/playlist.cpp
index f924a0faaa..24e63dac19 100644
--- a/wled00/playlist.cpp
+++ b/wled00/playlist.cpp
@@ -1,4 +1,5 @@
 #include "wled.h"
+#include "prng.h"
 
 /*
  * Handles playlists, timed sequences of presets
@@ -50,20 +51,13 @@ static uint32_t normalizeClockedPlaylistDuration(uint32_t durMs, uint32_t fallba
   return fallbackDur > 0 ? fallbackDur : CLOCKED_PLAYLIST_DEFAULT_DUR;
 }
 
-static uint32_t playlistShuffleRand(uint32_t &state) {
-  state ^= state << 13;
-  state ^= state >> 17;
-  state ^= state << 5;
-  return state;
-}
-
-static uint32_t clockedPlaylistSeed(uint32_t cycle) {
+static uint16_t clockedPlaylistSeed(uint32_t cycle) {
   uint32_t seed = 2166136261UL;
   seed = (seed ^ (uint32_t)currentPlaylist) * 16777619UL;
   seed = (seed ^ cycle) * 16777619UL;
   seed = (seed ^ playlistLen) * 16777619UL;
   if (seed == 0) seed = 2166136261UL;
-  return seed;
+  return (uint16_t)((seed >> 16) ^ seed);
 }
 
 static void applyPlaylistEntry(uint8_t index, uint32_t durMs) {
@@ -111,9 +105,9 @@ static bool getClockedPlaylistState(uint8_t &entryIndex, uint32_t &entryOffset)
   for (byte i = 0; i < playlistLen; i++) order[i] = i;
   if (playlistOptions & PL_OPTION_SHUFFLE) {
     // Keep shuffle deterministic for all controllers within the same wall-clock cycle.
-    uint32_t seed = clockedPlaylistSeed(cycle);
+    PRNG prng(clockedPlaylistSeed(cycle));
     for (int i = playlistLen - 1; i > 0; i--) {
-      int j = playlistShuffleRand(seed) % (i + 1);
+      int j = prng.random16(i + 1);
       uint8_t tmp = order[i];
       order[i] = order[j];
       order[j] = tmp;

From 4dee16761b1a584f5e1f23205cbe5d140cec8401 Mon Sep 17 00:00:00 2001
From: aeoa <64489515+aeoa@users.noreply.github.com>
Date: Thu, 4 Jun 2026 20:21:04 +0200
Subject: [PATCH 6/8] Split deterministic shuffle and wall time sync as
 separate features

---
 wled00/const.h       |   3 +-
 wled00/data/index.js | 117 +++++++++----------
 wled00/fcn_declare.h |   1 -
 wled00/playlist.cpp  | 267 ++++++++++++++++++++++---------------------
 4 files changed, 196 insertions(+), 192 deletions(-)

diff --git a/wled00/const.h b/wled00/const.h
index f5e431928e..6edf333218 100644
--- a/wled00/const.h
+++ b/wled00/const.h
@@ -448,7 +448,8 @@ static_assert(WLED_MAX_BUSSES <= 32, "WLED_MAX_BUSSES exceeds hard limit");
 //Playlist option byte
 #define PL_OPTION_SHUFFLE      0x01
 #define PL_OPTION_RESTORE      0x02
-#define PL_OPTION_CLOCKED      0x04
+#define PL_OPTION_DETERMINISTIC_SHUFFLE 0x04
+#define PL_OPTION_CLOCK_SYNC   0x08
 
 // Segment capability byte
 #define SEG_CAPABILITY_RGB     0x01
diff --git a/wled00/data/index.js b/wled00/data/index.js
index 70978710ba..4b4f3b4c2c 100644
--- a/wled00/data/index.js
+++ b/wled00/data/index.js
@@ -2004,19 +2004,47 @@ function pleTr(p,i,field)
 		plJson[p].transition[i] = Math.floor(field.value*10);
 }
 
-function plR(p)
+function plUpdateOptions(p, changed)
 {
 	var pl = plJson[p];
-	const clocked = gId(`pl${p}clocked`);
+
+	const shuffle = gId(`pl${p}rtgl`).checked;
+	const deterministic = gId(`pl${p}deterministic`);
+	const clockSync = gId(`pl${p}clockSync`);
 	const manual = gId(`pl${p}manual`);
-	const repeat = gId(`pl${p}rptgl`);
-	if (clocked.checked && !repeat.checked) {
-		clocked.checked = false;
-		manual.disabled = false;
-	}
-	pl.r = gId(`pl${p}rtgl`).checked;
-	pl.clocked = clocked.checked;
-	if (repeat.checked) { // infinite
+	let manualChanged = changed == "manual";
+
+	// Ensure clock sync and manual advance can't be checked at the same time
+	if (clockSync.checked && manual.checked) {
+		if (changed == "clockSync") {
+			manual.checked = false;
+			manualChanged = true;
+		} else {
+			clockSync.checked = false;
+		}
+	}
+
+	// Reset & hide deterministic flag when not shuffling
+	if (!shuffle) deterministic.checked = false;
+	gId(`pl${p}deterministicRow`).style.display = shuffle ? "block" : "none";
+
+	pl.r = shuffle;
+	pl.deterministic = deterministic.checked;
+	pl.clockSync = clockSync.checked;
+
+	// Normalize durations when manual advance changes
+	if (manualChanged) {
+		plJson[p].dur.forEach((_,i)=>{
+			const e = manual.checked ? 0 : 100;
+			const d = gId(`pl${p}du${i}`);
+			plJson[p].dur[i] = e;
+			d.value = e/10; // 10s default
+			d.readOnly = manual.checked;
+		});
+	}
+
+	// Update repeat/end-preset controls
+	if (gId(`pl${p}rptgl`).checked) { // infinite
 		pl.repeat = 0;
 		delete pl.end;
 		gId(`pl${p}o1`).style.display = "none";
@@ -2027,38 +2055,6 @@ function plR(p)
 	}
 }
 
-function plClock(p)
-{
-	const clocked = gId(`pl${p}clocked`).checked;
-	const manual = gId(`pl${p}manual`);
-	const repeat = gId(`pl${p}rptgl`);
-	if (clocked && manual.checked) {
-		manual.checked = false;
-		plM(p);
-	} else if (clocked) {
-		plJson[p].dur.forEach((e,i)=>{
-			if (e > 0) return;
-			plJson[p].dur[i] = 100;
-			const d = gId(`pl${p}du${i}`);
-			if (d) d.value = 10;
-		});
-	}
-	if (clocked && repeat) repeat.checked = true;
-	manual.disabled = clocked;
-	plR(p);
-}
-
-function plM(p)
-{
-	const man = gId(`pl${p}manual`).checked;
-	plJson[p].dur.forEach((e,i)=>{
-		const d = gId(`pl${p}du${i}`);
-		plJson[p].dur[i] = e = man ? 0 : 100;
-		d.value = e/10; // 10s default 
-		d.readOnly = man;
-	});
-}
-
 function makeP(i,pl)
 {
 	var content = "";
@@ -2070,38 +2066,39 @@ function makeP(i,pl)
 			transition: [tr],
 			repeat: 0,
 			r: false,
-			clocked: false,
+			deterministic: false,
+			clockSync: false,
 			end: 0
 		};
-		const clocked = !!plJson[i].clocked;
-		if (clocked) {
-			plJson[i].repeat = 0;
-			delete plJson[i].end;
-			plJson[i].dur = plJson[i].dur.map(d => d > 0 ? d : 100);
-		}
+		const clockSync = !!plJson[i].clockSync;
+		if (!plJson[i].r) plJson[i].deterministic = false;
 		const rep = plJson[i].repeat ? plJson[i].repeat : 0;
-		const man = !clocked && plJson[i].dur.every(d => d == 0);
+		const man = !clockSync && plJson[i].dur.every(d => d == 0);
 		content =
 `<div id="ple${i}" style="margin-top:10px;"></div><label class="check revchkl">Shuffle
-	<input type="checkbox" id="pl${i}rtgl" onchange="plR(${i})" ${plJson[i].r||rep<0?"checked":""}>
+	<input type="checkbox" id="pl${i}rtgl" onchange="plUpdateOptions(${i}, 'shuffle')" ${plJson[i].r||rep<0?"checked":""}>
+	<span class="checkmark"></span>
+</label>
+<label class="check revchkl" id="pl${i}deterministicRow" style="display:${plJson[i].r||rep<0?"block":"none"};margin-left:1.2em" title="Uses a repeatable shuffle order">Deterministic
+	<input type="checkbox" id="pl${i}deterministic" onchange="plUpdateOptions(${i}, 'deterministic')" ${plJson[i].deterministic?"checked":""}>
 	<span class="checkmark"></span>
 </label>
-<label class="check revchkl" title="Uses synced time; repeats indefinitely">Clock sync
-	<input type="checkbox" id="pl${i}clocked" onchange="plClock(${i})" ${clocked?"checked":""}>
+<label class="check revchkl" title="Derives playlist position from wall time">Clock sync
+	<input type="checkbox" id="pl${i}clockSync" onchange="plUpdateOptions(${i}, 'clockSync')" ${clockSync?"checked":""}>
 	<span class="checkmark"></span>
 </label>
 <label class="check revchkl">Manual advance
-	<input type="checkbox" id="pl${i}manual" onchange="plM(${i})" ${man?"checked":""} ${clocked?"disabled":""}>
+	<input type="checkbox" id="pl${i}manual" onchange="plUpdateOptions(${i}, 'manual')" ${man?"checked":""}>
 	<span class="checkmark"></span>
 </label>
 <label class="check revchkl">Repeat indefinitely
-	<input type="checkbox" id="pl${i}rptgl" onchange="plR(${i})" ${rep>0?"":"checked"}>
+	<input type="checkbox" id="pl${i}rptgl" onchange="plUpdateOptions(${i}, 'repeat')" ${rep>0?"":"checked"}>
 	<span class="checkmark"></span>
 </label>
 <div id="pl${i}o1" style="display:${rep>0?"block":"none"}">
-<div class="c">Repeat <input type="number" id="pl${i}rp" oninput="plR(${i})" max=127 min=0 value=${rep>0?rep:1}> times</div>
+<div class="c">Repeat <input type="number" id="pl${i}rp" oninput="plUpdateOptions(${i}, 'repeat')" max=127 min=0 value=${rep>0?rep:1}> times</div>
 <div class="sel">End preset:<br>
-<div class="sel-p"><select class="sel-ple" id="pl${i}selEnd" onchange="plR(${i})" data-val=${plJson[i].end?plJson[i].end:0}>
+<div class="sel-p"><select class="sel-ple" id="pl${i}selEnd" onchange="plUpdateOptions(${i}, 'repeat')" data-val=${plJson[i].end?plJson[i].end:0}>
 <option value="0">None</option>
 <option value="255" ${plJson[i].end && plJson[i].end==255?"selected":""}>Restore preset</option>
 ${makePlSel(i, plJson[i].end?plJson[i].end:0)}
@@ -2164,6 +2161,7 @@ function makePUtil()
 	p.classList.remove('staybot');
 	p.classList.add('pres');
 	p.innerHTML = `<div class="presin expanded">${makeP(0)}</div>`;
+	tooltip("#putil");
 	let pTx = gId('p0txt');
 	pTx.focus();
 	pTx.value = eJson.find((o)=>{return o.id==selectedFx}).name;
@@ -2213,6 +2211,7 @@ function makePlUtil()
 	p.classList.add('pres');
 	p.innerHTML = `<div class="presin expanded" id="seg100">${makeP(0,true)}</div></div>`;
 	refreshPlE(0);
+	tooltip("#putil");
 	gId('p0txt').focus();
 	p.scrollIntoView({
 		behavior: 'smooth',
@@ -3090,13 +3089,15 @@ function expand(i)
 				formatArr(plJson[p]);
 				if (isNaN(plJson[p].repeat)) plJson[p].repeat = 0;
 				if (!plJson[p].r) plJson[p].r = false;
-				if (!plJson[p].clocked) plJson[p].clocked = false;
+				if (!plJson[p].deterministic) plJson[p].deterministic = false;
+				if (!plJson[p].clockSync) plJson[p].clockSync = false;
 				if (isNaN(plJson[p].end)) plJson[p].end = 0;
 				gId('seg' +i).innerHTML = makeP(p,true);
 				refreshPlE(p);
 			} else {
 				gId('seg' +i).innerHTML = makeP(p);
 			}
+			tooltip('#seg' + i);
 			var papi = papiVal(p);
 			gId(`p${p}api`).value = papi;
 			if (papi.indexOf("Please") == 0) gId(`p${p}cstgl`).checked = false;
diff --git a/wled00/fcn_declare.h b/wled00/fcn_declare.h
index 6201a19192..884e3896f1 100644
--- a/wled00/fcn_declare.h
+++ b/wled00/fcn_declare.h
@@ -256,7 +256,6 @@ void handleOverlayDraw();
 // void _overlayAnalogClock();      // local function, only used in overlay.cpp
 
 //playlist.cpp
-void shufflePlaylist();
 void unloadPlaylist();
 int16_t loadPlaylist(JsonObject playlistObject, byte presetId = 0);
 void handlePlaylist();
diff --git a/wled00/playlist.cpp b/wled00/playlist.cpp
index 24e63dac19..129f0ce691 100644
--- a/wled00/playlist.cpp
+++ b/wled00/playlist.cpp
@@ -13,148 +13,99 @@ typedef struct PlaylistEntry {
 
 static byte           playlistRepeat = 1;        //how many times to repeat the playlist (0 = infinitely)
 static byte           playlistEndPreset = 0;     //what preset to apply after playlist end (0 = stay on last preset)
-static byte           playlistOptions = 0;       //bit 0: shuffle playlist after each iteration. bits 1-7 TBD
+static byte           playlistOptions = 0;       //PL_OPTION_*
 
 static PlaylistEntry *playlistEntries = nullptr;
+static byte          *playlistOrder = nullptr;
 static byte           playlistLen;               //number of playlist entries
 static int8_t         playlistIndex = -1;
 static uint32_t       playlistEntryDur = 0;      //duration of the current entry in milliseconds
-static bool           clockedPlaylistSynced = false;
+static uint64_t       playlistTotalDur = 0;      //sum of all entry durations in milliseconds
+static uint32_t       playlistCycleNum = 0;      //current playlist cycle for deterministic shuffle
 
 //values we need to keep about the parent playlist while inside sub-playlist
 static int16_t        parentPlaylistIndex = -1;
 static byte           parentPlaylistRepeat = 0;
 static byte           parentPlaylistPresetId = 0; //for re-loading
 
-
-void shufflePlaylist() {
-  int currentIndex = playlistLen;
-  PlaylistEntry temporaryValue;
-
-  // While there remain elements to shuffle...
-  while (currentIndex--) {
-    // Pick a random element...
-    int randomIndex = random(0, currentIndex);
-    // And swap it with the current element.
-    temporaryValue = playlistEntries[currentIndex];
-    playlistEntries[currentIndex] = playlistEntries[randomIndex];
-    playlistEntries[randomIndex] = temporaryValue;
-  }
-  DEBUG_PRINTLN(F("Playlist shuffle."));
+static void resetPlaylistOrder() {
+  if (playlistOrder == nullptr) return;
+  for (byte i = 0; i < playlistLen; i++) playlistOrder[i] = i;
 }
 
-// AI: below section was generated by an AI
-static const uint32_t CLOCKED_PLAYLIST_DEFAULT_DUR = 10000UL;
-
-static uint32_t normalizeClockedPlaylistDuration(uint32_t durMs, uint32_t fallbackDur) {
-  if (durMs > 0) return durMs;
-  return fallbackDur > 0 ? fallbackDur : CLOCKED_PLAYLIST_DEFAULT_DUR;
-}
-
-static uint16_t clockedPlaylistSeed(uint32_t cycle) {
+static uint16_t deterministicShuffleSeed() {
   uint32_t seed = 2166136261UL;
-  seed = (seed ^ (uint32_t)currentPlaylist) * 16777619UL;
-  seed = (seed ^ cycle) * 16777619UL;
+  seed = (seed ^ playlistCycleNum) * 16777619UL;
   seed = (seed ^ playlistLen) * 16777619UL;
   if (seed == 0) seed = 2166136261UL;
   return (uint16_t)((seed >> 16) ^ seed);
 }
 
-static void applyPlaylistEntry(uint8_t index, uint32_t durMs) {
-  playlistIndex = index;
-  jsonTransitionOnce = true;
-  strip.setTransition(playlistEntries[index].tr * 100);
-  playlistEntryDur = durMs;
-  applyPresetFromPlaylist(playlistEntries[index].preset);
-}
-// AI: end
+static void shufflePlaylist() {
+  if (playlistOrder == nullptr || playlistLen < 2) return;
+  resetPlaylistOrder();
+  bool deterministic = playlistOptions & PL_OPTION_DETERMINISTIC_SHUFFLE;
+  PRNG prng(deterministic ? deterministicShuffleSeed() : 0);
 
+  // While there remain elements to shuffle...
+  for (int currentIndex = playlistLen - 1; currentIndex > 0; currentIndex--) {
+    // Pick a random element...
+    int randomIndex = deterministic ? prng.random16(currentIndex + 1) : random(0, currentIndex + 1);
+    // And swap it with the current element.
+    byte temporaryValue = playlistOrder[currentIndex];
+    playlistOrder[currentIndex] = playlistOrder[randomIndex];
+    playlistOrder[randomIndex] = temporaryValue;
+  }
+  DEBUG_PRINTLN(F("Playlist shuffle."));
+}
 
 void unloadPlaylist() {
   if (playlistEntries != nullptr) {
     delete[] playlistEntries;
     playlistEntries = nullptr;
   }
+  if (playlistOrder != nullptr) {
+    delete[] playlistOrder;
+    playlistOrder = nullptr;
+  }
   currentPlaylist = playlistIndex = -1;
   playlistLen = 0;
   playlistOptions = 0;
   playlistEntryDur = 0;
-  clockedPlaylistSynced = false;
+  playlistTotalDur = 0;
+  playlistCycleNum = 0;
   DEBUG_PRINTLN(F("Playlist unloaded."));
 }
 
-// AI: below section was generated by an AI
-static bool getClockedPlaylistState(uint8_t &entryIndex, uint32_t &entryOffset) {
-  if (!(playlistOptions & PL_OPTION_CLOCKED) || playlistLen == 0 || playlistEntries == nullptr) return false;
+// Convert absolute Toki time into a playlist cycle number and elapsed time within that cycle
+static bool getClockSyncPlaylistCycle(uint32_t &cycleNum, uint64_t &cycleTime) {
+  if (!(playlistOptions & PL_OPTION_CLOCK_SYNC) || playlistTotalDur == 0) return false;
   if (toki.getTimeSource() == TOKI_TS_NONE) return false;
 
-  // Clocked playlists live on an absolute Toki timeline; every entry must have finite duration.
-  uint64_t cycleDur = 0;
-  for (byte i = 0; i < playlistLen; i++) {
-    if (playlistEntries[i].dur == 0) return false; // infinite entries cannot be placed on a repeating wall-clock timeline
-    cycleDur += playlistEntries[i].dur;
-  }
-  if (cycleDur == 0) return false;
-
   Toki::Time tm = toki.getTime();
   uint64_t absoluteMs = (uint64_t)tm.sec * 1000ULL + tm.ms;
-  uint32_t cycle = (uint32_t)(absoluteMs / cycleDur);
-  uint64_t cycleOffset = absoluteMs % cycleDur;
-
-  uint8_t order[100];
-  for (byte i = 0; i < playlistLen; i++) order[i] = i;
-  if (playlistOptions & PL_OPTION_SHUFFLE) {
-    // Keep shuffle deterministic for all controllers within the same wall-clock cycle.
-    PRNG prng(clockedPlaylistSeed(cycle));
-    for (int i = playlistLen - 1; i > 0; i--) {
-      int j = prng.random16(i + 1);
-      uint8_t tmp = order[i];
-      order[i] = order[j];
-      order[j] = tmp;
-    }
-  }
-
-  for (byte i = 0; i < playlistLen; i++) {
-    uint8_t orderedIndex = order[i];
-    uint32_t dur = playlistEntries[orderedIndex].dur;
-    if (cycleOffset < dur) {
-      entryIndex = orderedIndex;
-      entryOffset = (uint32_t)cycleOffset;
-      return true;
-    }
-    cycleOffset -= dur;
-  }
-
-  entryIndex = order[playlistLen - 1];
-  entryOffset = playlistEntries[entryIndex].dur - 1;
+  cycleNum = (uint32_t)(absoluteMs / playlistTotalDur);
+  cycleTime = absoluteMs % playlistTotalDur;
   return true;
 }
 
-static void handleClockedPlaylist() {
-  if (toki.getTimeSource() == TOKI_TS_NONE) {
-    if (playlistIndex < 0 && !nightlightActive) {
-      strip.resetTimebase();
-      uint32_t durMs = playlistEntries[0].dur > 0 ? playlistEntries[0].dur : UINT32_MAX;
-      applyPlaylistEntry(0, durMs);
+// Map elapsed time inside the current wall-clock cycleNum to a slot in playlistOrder
+// and the elapsed time inside that slot
+static bool mapCycleTimeToPlaylistSlot(uint64_t cycleTime, int8_t &entrySlot, uint32_t &entryOffset) {
+  if (playlistLen == 0 || playlistEntries == nullptr || playlistOrder == nullptr) return false;
+
+  for (byte i = 0; i < playlistLen; i++) {
+    uint32_t dur = playlistEntries[playlistOrder[i]].dur;
+    if (cycleTime < dur) {
+      entrySlot = i;
+      entryOffset = (uint32_t)cycleTime;
+      return true;
     }
-    return;
+    cycleTime -= dur;
   }
 
-  uint8_t derivedIndex = 0;
-  uint32_t entryOffset = 0;
-  if (!getClockedPlaylistState(derivedIndex, entryOffset)) return;
-  if (nightlightActive) return;
-
-  strip.timebase = (unsigned long)entryOffset - millis();
-
-  if (!clockedPlaylistSynced || playlistIndex != (int8_t)derivedIndex) {
-    applyPlaylistEntry(derivedIndex, playlistEntries[derivedIndex].dur);
-  }
-  clockedPlaylistSynced = true;
-  doAdvancePlaylist = false;
+  return false;
 }
-// AI: end
-
 
 int16_t loadPlaylist(JsonObject playlistObj, byte presetId) {
   if (currentPlaylist > 0 && parentPlaylistPresetId > 0) return -1; // we are already in nested playlist, do nothing
@@ -169,10 +120,16 @@ int16_t loadPlaylist(JsonObject playlistObj, byte presetId) {
   playlistLen = presets.size();
   if (playlistLen == 0) return -1;
   if (playlistLen > 100) playlistLen = 100;
-  bool clocked = playlistObj[F("clocked")] | false;
 
   playlistEntries = new(std::nothrow) PlaylistEntry[playlistLen];
   if (playlistEntries == nullptr) return -1;
+  playlistOrder = new(std::nothrow) byte[playlistLen];
+  if (playlistOrder == nullptr) {
+    delete[] playlistEntries;
+    playlistEntries = nullptr;
+    return -1;
+  }
+  resetPlaylistOrder();
 
   byte it = 0;
   for (int ps : presets) {
@@ -186,22 +143,20 @@ int16_t loadPlaylist(JsonObject playlistObj, byte presetId) {
   if (durations.isNull()) {
     uint32_t durMs = playlistObj["dur"] | 100; // 10 seconds as fallback (tenths)
     durMs = constrain(durMs, 0L, 42949670L) * 100UL; // limit to max value and convert to ms
-    if (clocked) durMs = normalizeClockedPlaylistDuration(durMs, CLOCKED_PLAYLIST_DEFAULT_DUR);
     playlistEntries[0].dur = (uint32_t)durMs;
     it = 1;
   } else {
-    uint32_t fallbackDur = CLOCKED_PLAYLIST_DEFAULT_DUR;
     for (int dur : durations) {
       if (it >= playlistLen) break;
       uint32_t durMs = constrain(dur, 0L, 42949670L) * 100UL; // limit to max value and convert to ms
-      if (clocked) durMs = normalizeClockedPlaylistDuration(durMs, fallbackDur);
       playlistEntries[it].dur = (uint32_t)durMs;
-      fallbackDur = durMs;
       it++;
     }
   }
   if (it > 0) // should never happen but just in case
     for (int i = it; i < playlistLen; i++) playlistEntries[i].dur = playlistEntries[it -1].dur;
+  playlistTotalDur = 0;
+  for (int i = 0; i < playlistLen; i++) playlistTotalDur += playlistEntries[i].dur;
 
   it = 0;
   JsonArray tr = playlistObj[F("transition")];
@@ -232,10 +187,15 @@ int16_t loadPlaylist(JsonObject playlistObj, byte presetId) {
     playlistOptions |= PL_OPTION_RESTORE; // for async save operation
   }
   if (playlistEndPreset > 250) playlistEndPreset = 0;
-  shuffle = shuffle || playlistObj["r"];
-  if (clocked) playlistOptions |= PL_OPTION_CLOCKED;
+  shuffle = shuffle || playlistObj["r"].as<bool>();
   if (shuffle) playlistOptions |= PL_OPTION_SHUFFLE;
 
+  bool clockSync = playlistObj[F("clockSync")].as<bool>();
+  if (clockSync) playlistOptions |= PL_OPTION_CLOCK_SYNC;
+
+  bool deterministicShuffle = playlistObj[F("deterministic")].as<bool>();
+  if (shuffle && deterministicShuffle) playlistOptions |= PL_OPTION_DETERMINISTIC_SHUFFLE;
+
   if (parentPlaylistPresetId == 0 && parentPlaylistIndex > -1) {
     // we are re-loading playlist when returning from nested playlist
     playlistIndex = parentPlaylistIndex;
@@ -257,36 +217,78 @@ int16_t loadPlaylist(JsonObject playlistObj, byte presetId) {
 
 void handlePlaylist() {
   static unsigned long presetCycledTime = 0;
-  if (currentPlaylist < 0 || playlistEntries == nullptr) return;
+  if (currentPlaylist < 0 || playlistEntries == nullptr || playlistOrder == nullptr) return;
+
+  unsigned long now = millis();
+  uint64_t clockSyncCycleTime = 0;
+  uint32_t targetCycleNum = playlistCycleNum;
+  int8_t targetPlaylistIndex = playlistIndex;
+  bool clockSyncTimeValid = false;
+  bool needsRollover = false;
+  bool shouldApplyEntry = false;
+
+  // Derive wall-clock rollover state
+  if (playlistOptions & PL_OPTION_CLOCK_SYNC) {
+    uint32_t cycleNum = 0;
+    if (getClockSyncPlaylistCycle(cycleNum, clockSyncCycleTime)) {
+      clockSyncTimeValid = true;
+      targetCycleNum = cycleNum;
+      if (playlistIndex < 0 || playlistCycleNum != targetCycleNum) needsRollover = true;
+      // Clock-synced playlists derive the active slot from wall time, so manual "next preset" cannot persist.
+      doAdvancePlaylist = false;
+    }
+  }
+
+  // Derive local-clock/manual advance state
+  if (!clockSyncTimeValid && ((playlistEntryDur < UINT32_MAX && now - presetCycledTime > playlistEntryDur) || doAdvancePlaylist)) {
+    presetCycledTime = now;
+
+    targetPlaylistIndex = (playlistIndex + 1) % playlistLen; // -1 at 1st run (limit to playlistLen)
 
-  if (playlistOptions & PL_OPTION_CLOCKED) {
-    handleClockedPlaylist();
-    return;
+    if (!targetPlaylistIndex) {
+      if (playlistIndex >= 0) targetCycleNum++;
+      needsRollover = true;
+    }
+
+    shouldApplyEntry = true;
+  }
+
+  if (bri == 0 || nightlightActive) return;
+
+  // Apply rollover
+  if (needsRollover) {
+    playlistCycleNum = targetCycleNum;
+    if (playlistRepeat == 1) { //stop if all repetitions are done
+      unloadPlaylist();
+      if (parentPlaylistPresetId > 0) {
+        applyPresetFromPlaylist(parentPlaylistPresetId); // reload previous playlist (unfortunately asynchronous)
+        parentPlaylistPresetId = 0; // reset previous playlist but do not reset Index or Repeat (they will be loaded & reset in loadPlaylist())
+      } else if (playlistEndPreset) applyPresetFromPlaylist(playlistEndPreset);
+      return;
+    }
+    if (playlistRepeat > 1) playlistRepeat--; // decrease repeat count on each index reset if not an endless playlist
+    // playlistRepeat == 0: endless loop
+    if (playlistOptions & PL_OPTION_SHUFFLE) shufflePlaylist(); // shuffle playlist and start over
   }
 
-  if ((playlistEntryDur < UINT32_MAX && millis() - presetCycledTime > playlistEntryDur) || doAdvancePlaylist) {
-    presetCycledTime = millis();
-    if (bri == 0 || nightlightActive) return;
-
-    ++playlistIndex %= playlistLen; // -1 at 1st run (limit to playlistLen)
-
-    // playlist roll-over
-    if (!playlistIndex) {
-      if (playlistRepeat == 1) { //stop if all repetitions are done
-        unloadPlaylist();
-        if (parentPlaylistPresetId > 0) {
-          applyPresetFromPlaylist(parentPlaylistPresetId); // reload previous playlist (unfortunately asynchronous)
-          parentPlaylistPresetId = 0; // reset previous playlist but do not reset Index or Repeat (they will be loaded & reset in loadPlaylist())
-        } else if (playlistEndPreset) applyPresetFromPlaylist(playlistEndPreset);
-        return;
-      }
-      if (playlistRepeat > 1) playlistRepeat--; // decrease repeat count on each index reset if not an endless playlist
-      // playlistRepeat == 0: endless loop
-      if (playlistOptions & PL_OPTION_SHUFFLE) shufflePlaylist(); // shuffle playlist and start over
+  // Map wall-clock time to the active playlist slot
+  if (clockSyncTimeValid) {
+    uint32_t clockSyncEntryOffset = 0;
+    if (mapCycleTimeToPlaylistSlot(clockSyncCycleTime, targetPlaylistIndex, clockSyncEntryOffset)) {
+      presetCycledTime = now - clockSyncEntryOffset;
+      shouldApplyEntry = needsRollover || playlistIndex != targetPlaylistIndex;
+      strip.timebase = (unsigned long)clockSyncEntryOffset - now;
     }
+  }
 
-    uint32_t durMs = playlistEntries[playlistIndex].dur > 0 ? playlistEntries[playlistIndex].dur : UINT32_MAX; // UINT32_MAX means infinite
-    applyPlaylistEntry(playlistIndex, durMs);
+  // Apply the selected playlist entry
+  if (shouldApplyEntry) {
+    playlistIndex = targetPlaylistIndex;
+    jsonTransitionOnce = true;
+    PlaylistEntry &entry = playlistEntries[playlistOrder[playlistIndex]];
+    strip.setTransition(entry.tr * 100);
+    playlistEntryDur = entry.dur > 0 ? entry.dur : UINT32_MAX; // UINT32_MAX means infinite
+    applyPresetFromPlaylist(entry.preset);
     doAdvancePlaylist = false;
   }
 }
@@ -299,8 +301,9 @@ void serializePlaylist(JsonObject sObj) {
   JsonArray transition = playlist.createNestedArray(F("transition"));
   playlist[F("repeat")] = (playlistIndex < 0 && playlistRepeat > 0) ? playlistRepeat - 1 : playlistRepeat; // remove added repetition count (if not yet running)
   playlist["end"] = playlistOptions & PL_OPTION_RESTORE ? 255 : playlistEndPreset;
-  playlist["r"] = playlistOptions & PL_OPTION_SHUFFLE;
-  playlist[F("clocked")] = (playlistOptions & PL_OPTION_CLOCKED) != 0;
+  playlist["r"] = (playlistOptions & PL_OPTION_SHUFFLE) != 0;
+  playlist[F("deterministic")] = (playlistOptions & PL_OPTION_DETERMINISTIC_SHUFFLE) != 0;
+  playlist[F("clockSync")] = (playlistOptions & PL_OPTION_CLOCK_SYNC) != 0;
   for (int i=0; i<playlistLen; i++) {
     ps.add(playlistEntries[i].preset);
     dur.add((playlistEntries[i].dur) / 100); // convert ms back to tenths of seconds (backwards compatibility)

From ec7a5956be20f4fa5c7956c430e73edead4146c3 Mon Sep 17 00:00:00 2001
From: aeoa <64489515+aeoa@users.noreply.github.com>
Date: Sat, 6 Jun 2026 12:57:59 +0200
Subject: [PATCH 7/8] Replace playlistOrder array with deterministic
 unshuffling

---
 wled00/playlist.cpp | 65 +++++++++++++++++++++++----------------------
 wled00/prng.h       | 13 +++++++++
 2 files changed, 46 insertions(+), 32 deletions(-)

diff --git a/wled00/playlist.cpp b/wled00/playlist.cpp
index 129f0ce691..2a3bb764c1 100644
--- a/wled00/playlist.cpp
+++ b/wled00/playlist.cpp
@@ -16,23 +16,19 @@ static byte           playlistEndPreset = 0;     //what preset to apply after pl
 static byte           playlistOptions = 0;       //PL_OPTION_*
 
 static PlaylistEntry *playlistEntries = nullptr;
-static byte          *playlistOrder = nullptr;
 static byte           playlistLen;               //number of playlist entries
 static int8_t         playlistIndex = -1;
 static uint32_t       playlistEntryDur = 0;      //duration of the current entry in milliseconds
 static uint64_t       playlistTotalDur = 0;      //sum of all entry durations in milliseconds
 static uint32_t       playlistCycleNum = 0;      //current playlist cycle for deterministic shuffle
+static PRNG           prng;
+static bool           playlistEntriesAreShuffled = false;
 
 //values we need to keep about the parent playlist while inside sub-playlist
 static int16_t        parentPlaylistIndex = -1;
 static byte           parentPlaylistRepeat = 0;
 static byte           parentPlaylistPresetId = 0; //for re-loading
 
-static void resetPlaylistOrder() {
-  if (playlistOrder == nullptr) return;
-  for (byte i = 0; i < playlistLen; i++) playlistOrder[i] = i;
-}
-
 static uint16_t deterministicShuffleSeed() {
   uint32_t seed = 2166136261UL;
   seed = (seed ^ playlistCycleNum) * 16777619UL;
@@ -41,22 +37,36 @@ static uint16_t deterministicShuffleSeed() {
   return (uint16_t)((seed >> 16) ^ seed);
 }
 
+static void unShufflePlaylist() {
+  if (playlistEntries == nullptr || playlistLen < 2 || !playlistEntriesAreShuffled || !(playlistOptions & PL_OPTION_DETERMINISTIC_SHUFFLE)) return;
+
+  PlaylistEntry temp;
+  for (int currentIndex = 1; currentIndex < playlistLen; currentIndex++) {
+    int randomIndex = prng.random16Backwards(currentIndex + 1);
+    temp = playlistEntries[currentIndex];
+    playlistEntries[currentIndex] = playlistEntries[randomIndex];
+    playlistEntries[randomIndex] = temp;
+  }
+  playlistEntriesAreShuffled = false;
+}
+
 static void shufflePlaylist() {
-  if (playlistOrder == nullptr || playlistLen < 2) return;
-  resetPlaylistOrder();
+  if (playlistEntries == nullptr || playlistLen < 2) return;
+
   bool deterministic = playlistOptions & PL_OPTION_DETERMINISTIC_SHUFFLE;
-  PRNG prng(deterministic ? deterministicShuffleSeed() : 0);
+  if (deterministic) {
+    unShufflePlaylist();
+    prng.setSeed(deterministicShuffleSeed());
+  }
 
-  // While there remain elements to shuffle...
+  PlaylistEntry temp;
   for (int currentIndex = playlistLen - 1; currentIndex > 0; currentIndex--) {
-    // Pick a random element...
     int randomIndex = deterministic ? prng.random16(currentIndex + 1) : random(0, currentIndex + 1);
-    // And swap it with the current element.
-    byte temporaryValue = playlistOrder[currentIndex];
-    playlistOrder[currentIndex] = playlistOrder[randomIndex];
-    playlistOrder[randomIndex] = temporaryValue;
+    temp = playlistEntries[currentIndex];
+    playlistEntries[currentIndex] = playlistEntries[randomIndex];
+    playlistEntries[randomIndex] = temp;
   }
-  DEBUG_PRINTLN(F("Playlist shuffle."));
+  playlistEntriesAreShuffled = true;
 }
 
 void unloadPlaylist() {
@@ -64,16 +74,13 @@ void unloadPlaylist() {
     delete[] playlistEntries;
     playlistEntries = nullptr;
   }
-  if (playlistOrder != nullptr) {
-    delete[] playlistOrder;
-    playlistOrder = nullptr;
-  }
   currentPlaylist = playlistIndex = -1;
   playlistLen = 0;
   playlistOptions = 0;
   playlistEntryDur = 0;
   playlistTotalDur = 0;
   playlistCycleNum = 0;
+  playlistEntriesAreShuffled = false;
   DEBUG_PRINTLN(F("Playlist unloaded."));
 }
 
@@ -89,13 +96,13 @@ static bool getClockSyncPlaylistCycle(uint32_t &cycleNum, uint64_t &cycleTime) {
   return true;
 }
 
-// Map elapsed time inside the current wall-clock cycleNum to a slot in playlistOrder
+// Map elapsed time inside the current wall-clock cycleNum to a slot in playlistEntries
 // and the elapsed time inside that slot
 static bool mapCycleTimeToPlaylistSlot(uint64_t cycleTime, int8_t &entrySlot, uint32_t &entryOffset) {
-  if (playlistLen == 0 || playlistEntries == nullptr || playlistOrder == nullptr) return false;
+  if (playlistLen == 0 || playlistEntries == nullptr) return false;
 
   for (byte i = 0; i < playlistLen; i++) {
-    uint32_t dur = playlistEntries[playlistOrder[i]].dur;
+    uint32_t dur = playlistEntries[i].dur;
     if (cycleTime < dur) {
       entrySlot = i;
       entryOffset = (uint32_t)cycleTime;
@@ -123,13 +130,6 @@ int16_t loadPlaylist(JsonObject playlistObj, byte presetId) {
 
   playlistEntries = new(std::nothrow) PlaylistEntry[playlistLen];
   if (playlistEntries == nullptr) return -1;
-  playlistOrder = new(std::nothrow) byte[playlistLen];
-  if (playlistOrder == nullptr) {
-    delete[] playlistEntries;
-    playlistEntries = nullptr;
-    return -1;
-  }
-  resetPlaylistOrder();
 
   byte it = 0;
   for (int ps : presets) {
@@ -137,6 +137,7 @@ int16_t loadPlaylist(JsonObject playlistObj, byte presetId) {
     playlistEntries[it].preset = ps;
     it++;
   }
+  playlistEntriesAreShuffled = false;
 
   it = 0;
   JsonArray durations = playlistObj["dur"];
@@ -217,7 +218,7 @@ int16_t loadPlaylist(JsonObject playlistObj, byte presetId) {
 
 void handlePlaylist() {
   static unsigned long presetCycledTime = 0;
-  if (currentPlaylist < 0 || playlistEntries == nullptr || playlistOrder == nullptr) return;
+  if (currentPlaylist < 0 || playlistEntries == nullptr) return;
 
   unsigned long now = millis();
   uint64_t clockSyncCycleTime = 0;
@@ -285,7 +286,7 @@ void handlePlaylist() {
   if (shouldApplyEntry) {
     playlistIndex = targetPlaylistIndex;
     jsonTransitionOnce = true;
-    PlaylistEntry &entry = playlistEntries[playlistOrder[playlistIndex]];
+    PlaylistEntry &entry = playlistEntries[playlistIndex];
     strip.setTransition(entry.tr * 100);
     playlistEntryDur = entry.dur > 0 ? entry.dur : UINT32_MAX; // UINT32_MAX means infinite
     applyPresetFromPlaylist(entry.preset);
diff --git a/wled00/prng.h b/wled00/prng.h
index da0a84f124..93b47bdb14 100644
--- a/wled00/prng.h
+++ b/wled00/prng.h
@@ -20,4 +20,17 @@ class PRNG {
   uint8_t random8() { return random16(); }
   uint8_t random8(uint8_t lim) { return (uint8_t)(((uint16_t)random8() * lim) >> 8); }
   uint8_t random8(uint8_t min, uint8_t lim) { uint8_t delta = lim - min; return random8(delta) + min; }
+
+  uint16_t random16Backwards() {
+    uint16_t x = seed;
+    seed ^= seed >> 7;
+    seed ^= seed >> 14;
+    seed = (seed - 31683) * 35465;
+    return x;
+  }
+  uint16_t random16Backwards(uint16_t lim) { return ((uint32_t)random16Backwards() * lim) >> 16; }
+  uint16_t random16Backwards(uint16_t min, uint16_t lim) { uint16_t delta = lim - min; return random16Backwards(delta) + min; }
+  uint8_t random8Backwards() { return random16Backwards(); }
+  uint8_t random8Backwards(uint8_t lim) { return (uint8_t)(((uint16_t)random8Backwards() * lim) >> 8); }
+  uint8_t random8Backwards(uint8_t min, uint8_t lim) { uint8_t delta = lim - min; return random8Backwards(delta) + min; }
 };

From 734dc73ef6195bda45f2157ecf9fdd639c8faa59 Mon Sep 17 00:00:00 2001
From: aeoa <64489515+aeoa@users.noreply.github.com>
Date: Sat, 6 Jun 2026 14:21:49 +0200
Subject: [PATCH 8/8] Make mapCycleTimeToPlaylistSlot O(1) for the normal case

---
 wled00/playlist.cpp | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/wled00/playlist.cpp b/wled00/playlist.cpp
index 2a3bb764c1..5eb73a1bed 100644
--- a/wled00/playlist.cpp
+++ b/wled00/playlist.cpp
@@ -18,6 +18,7 @@ static byte           playlistOptions = 0;       //PL_OPTION_*
 static PlaylistEntry *playlistEntries = nullptr;
 static byte           playlistLen;               //number of playlist entries
 static int8_t         playlistIndex = -1;
+static uint64_t       clockSyncEntryStart = UINT64_MAX; //cycle time where playlistIndex starts
 static uint32_t       playlistEntryDur = 0;      //duration of the current entry in milliseconds
 static uint64_t       playlistTotalDur = 0;      //sum of all entry durations in milliseconds
 static uint32_t       playlistCycleNum = 0;      //current playlist cycle for deterministic shuffle
@@ -48,6 +49,8 @@ static void unShufflePlaylist() {
     playlistEntries[randomIndex] = temp;
   }
   playlistEntriesAreShuffled = false;
+  clockSyncEntryStart = UINT64_MAX;
+  DEBUG_PRINTLN(F("Playlist unshuffled."));
 }
 
 static void shufflePlaylist() {
@@ -67,6 +70,8 @@ static void shufflePlaylist() {
     playlistEntries[randomIndex] = temp;
   }
   playlistEntriesAreShuffled = true;
+  clockSyncEntryStart = UINT64_MAX;
+  DEBUG_PRINTLN(F("Playlist shuffled."));
 }
 
 void unloadPlaylist() {
@@ -81,6 +86,7 @@ void unloadPlaylist() {
   playlistTotalDur = 0;
   playlistCycleNum = 0;
   playlistEntriesAreShuffled = false;
+  clockSyncEntryStart = UINT64_MAX;
   DEBUG_PRINTLN(F("Playlist unloaded."));
 }
 
@@ -101,16 +107,26 @@ static bool getClockSyncPlaylistCycle(uint32_t &cycleNum, uint64_t &cycleTime) {
 static bool mapCycleTimeToPlaylistSlot(uint64_t cycleTime, int8_t &entrySlot, uint32_t &entryOffset) {
   if (playlistLen == 0 || playlistEntries == nullptr) return false;
 
-  for (byte i = 0; i < playlistLen; i++) {
+  byte startIndex = 0;
+  uint64_t entryStart = 0;
+  if (clockSyncEntryStart < playlistTotalDur && playlistIndex >= 0 && playlistIndex < playlistLen && cycleTime >= clockSyncEntryStart) {
+    startIndex = playlistIndex;
+    entryStart = clockSyncEntryStart;
+    cycleTime -= clockSyncEntryStart;
+  }
+
+  for (byte i = startIndex; i < playlistLen; i++) {
     uint32_t dur = playlistEntries[i].dur;
     if (cycleTime < dur) {
       entrySlot = i;
       entryOffset = (uint32_t)cycleTime;
+      clockSyncEntryStart = entryStart;
       return true;
     }
     cycleTime -= dur;
+    entryStart += dur;
   }
-
+  
   return false;
 }
 
@@ -285,6 +301,7 @@ void handlePlaylist() {
   // Apply the selected playlist entry
   if (shouldApplyEntry) {
     playlistIndex = targetPlaylistIndex;
+    if (!clockSyncTimeValid) clockSyncEntryStart = UINT64_MAX;
     jsonTransitionOnce = true;
     PlaylistEntry &entry = playlistEntries[playlistIndex];
     strip.setTransition(entry.tr * 100);