@digilogiclabs/saas-factory-ui 2.2.0 → 2.4.0

package/dist/web/index.mjs

@@ -30226,10 +30226,10 @@ function TiltCard({
 // src/components/ui/dice-roller/index.tsx
 import {
   useCallback as useCallback41,
-  useEffect as useEffect52,
+  useEffect as useEffect51,
   useMemo as useMemo26,
   useRef as useRef40,
-  useState as useState67
+  useState as useState66
 } from "react";
 
 // src/hooks/web/use-dark-mode.ts
@@ -30279,21 +30279,6 @@ function useDarkMode(forced) {
   return dark;
 }
 
-// src/hooks/web/use-prefers-reduced-motion.ts
-import { useEffect as useEffect51, useState as useState66 } from "react";
-function usePrefersReducedMotion() {
-  const [reduced, setReduced] = useState66(false);
-  useEffect51(() => {
-    if (typeof window === "undefined" || !window.matchMedia) return;
-    const mq = window.matchMedia("(prefers-reduced-motion: reduce)");
-    setReduced(mq.matches);
-    const read = () => setReduced(mq.matches);
-    mq.addEventListener("change", read);
-    return () => mq.removeEventListener("change", read);
-  }, []);
-  return reduced;
-}
-
 // src/components/ui/dice-roller/index.tsx
 import { Fragment as Fragment30, jsx as jsx113, jsxs as jsxs86 } from "react/jsx-runtime";
 var PRESETS = {
@@ -30366,14 +30351,35 @@ var PIP_POS = {
     [75, 75]
   ]
 };
-var SHOW_ROT = {
+var D6_FACE_PLACEMENTS = {
   1: { x: 0, y: 0 },
-  2: { x: 0, y: 180 },
-  3: { x: 0, y: -90 },
-  4: { x: 0, y: 90 },
-  5: { x: -90, y: 0 },
-  6: { x: 90, y: 0 }
+  2: { x: 0, y: 90 },
+  3: { x: 90, y: 0 },
+  4: { x: -90, y: 0 },
+  5: { x: 0, y: -90 },
+  6: { x: 0, y: 180 }
+};
+function d6LandingRotation(value) {
+  const p = D6_FACE_PLACEMENTS[value];
+  return {
+    x: Math.abs(p.x) === 180 ? 180 : -p.x || 0,
+    y: Math.abs(p.y) === 180 ? 180 : -p.y || 0
+  };
+}
+var POLY_SHAPES = {
+  4: { points: "50,8 93,86 7,86", textY: 62, fontScale: 0.3 },
+  8: { points: "50,4 96,50 50,96 4,50", textY: 51, fontScale: 0.33 },
+  10: { points: "50,4 93,44 50,96 7,44", textY: 47, fontScale: 0.3 },
+  12: { points: "50,4 95,37 78,93 22,93 5,37", textY: 54, fontScale: 0.33 },
+  20: {
+    points: "50,3 91,26 91,74 50,97 9,74 9,26",
+    textY: 51,
+    fontScale: 0.33
+  }
 };
+function formatDieValue(v, sides) {
+  return sides > 8 && (v === 6 || v === 9) ? `${v}.` : String(v);
+}
 var MAX_COUNT = 6;
 var TUMBLE_MS = 950;
 var SETTLE_MS = 1100;
@@ -30491,8 +30497,8 @@ function simulateDice(arenaW, arenaH, diceSize, starts, numDice) {
   return frames;
 }
 function useArenaBounds(ref) {
-  const [bounds, setBounds] = useState67({ w: 400, h: 260 });
-  useEffect52(() => {
+  const [bounds, setBounds] = useState66({ w: 400, h: 260 });
+  useEffect51(() => {
     if (!ref.current) return;
     const el = ref.current;
     const update = () => setBounds({ w: el.offsetWidth, h: el.offsetHeight });
@@ -30525,6 +30531,7 @@ function Face({ value, pipColor, pipShadow, pipDiameter }) {
 }
 function DiceRoller({
   count: count2 = 2,
+  sides = 6,
   theme: theme5 = "red",
   darkMode,
   size = 80,
@@ -30546,13 +30553,13 @@ function DiceRoller({
 }) {
   const clampedCount = Math.max(1, Math.min(MAX_COUNT, count2));
   const dark = useDarkMode(darkMode);
-  const reducedMotion = usePrefersReducedMotion();
-  const [rolling, setRolling] = useState67(false);
-  const [results, setResults] = useState67(null);
-  const [history, setHistory] = useState67([]);
+  const [rolling, setRolling] = useState66(false);
+  const [results, setResults] = useState66(null);
+  const [history, setHistory] = useState66([]);
   const dieWrapperRefs = useRef40([]);
   const cubeRefs = useRef40([]);
   const shadowRefs = useRef40([]);
+  const numeralRefs = useRef40([]);
   const currentPositionsRef = useRef40(null);
   const rollingRef = useRef40(false);
   const dieSetters = useRef40([]);
@@ -30582,6 +30589,15 @@ function DiceRoller({
     }
     return shadowSetters.current[i];
   };
+  const numeralSetters = useRef40([]);
+  const getNumeralSetter = (i) => {
+    if (!numeralSetters.current[i]) {
+      numeralSetters.current[i] = (el) => {
+        numeralRefs.current[i] = el;
+      };
+    }
+    return numeralSetters.current[i];
+  };
   const timersRef = useRef40([]);
   const rafHandleRef = useRef40(null);
   const arenaRef = useRef40(null);
@@ -30634,15 +30650,15 @@ function DiceRoller({
   const pipDiameter = Math.round(effectiveSize * 0.2);
   const faceRadius = Math.round(effectiveSize * 0.07);
   const arenaHeight = arenaHeightProp ?? Math.max(effectiveSize * 3, 200);
-  const faceTransforms = useMemo26(
-    () => [
-      `translateZ(${half}px)`,
-      `rotateY(180deg) translateZ(${half}px)`,
-      `rotateY(-90deg) translateZ(${half}px)`,
-      `rotateY(90deg) translateZ(${half}px)`,
-      `rotateX(90deg) translateZ(${half}px)`,
-      `rotateX(-90deg) translateZ(${half}px)`
-    ],
+  const faceTransformFor = useCallback41(
+    (value) => {
+      const p = D6_FACE_PLACEMENTS[value];
+      const parts = [];
+      if (p.x !== 0) parts.push(`rotateX(${p.x}deg)`);
+      if (p.y !== 0) parts.push(`rotateY(${p.y}deg)`);
+      parts.push(`translateZ(${half}px)`);
+      return parts.join(" ");
+    },
     [half]
   );
   const defaultPositions = useCallback41(
@@ -30664,15 +30680,23 @@ function DiceRoller({
     [half]
   );
   const writeCubeRotation = useCallback41(
-    (i, rx, ry, rz, withTransition) => {
+    (i, rx, ry, rz, withTransition, tiltZ = 0) => {
       const el = cubeRefs.current[i];
       if (!el) return;
       el.style.transition = withTransition ? "transform 0.95s cubic-bezier(0.12,0.8,0.22,1)" : "none";
-      el.style.transform = `rotateX(${rx}deg) rotateY(${ry}deg) rotateZ(${rz}deg)`;
+      el.style.transform = `${tiltZ ? `rotateZ(${tiltZ}deg) ` : ""}rotateX(${rx}deg) rotateY(${ry}deg) rotateZ(${rz}deg)`;
     },
     []
   );
-  useEffect52(() => {
+  useEffect51(() => {
+    if (timersRef.current.length > 0) {
+      timersRef.current.forEach((t) => clearTimeout(t));
+      timersRef.current = [];
+    }
+    if (rollingRef.current) {
+      rollingRef.current = false;
+      setRolling(false);
+    }
     const rawW = arenaRef.current?.offsetWidth ?? 0;
     const rawH = arenaRef.current?.offsetHeight ?? 0;
     const w = rawW > 20 ? rawW : arena.w > 20 ? arena.w : 400;
@@ -30698,19 +30722,23 @@ function DiceRoller({
     setResults(null);
   }, [
     clampedCount,
+    sides,
     effectiveSize,
     arena.w,
     arenaHeight,
     defaultPositions,
     half
   ]);
+  useEffect51(() => {
+    setHistory([]);
+  }, [sides]);
   const roll = useCallback41(() => {
     if (rollingRef.current) return;
     rollingRef.current = true;
     setRolling(true);
     const vals = Array.from(
       { length: clampedCount },
-      () => Math.floor(Math.random() * 6) + 1
+      () => Math.floor(Math.random() * sides) + 1
     );
     timersRef.current.forEach((t) => clearTimeout(t));
     timersRef.current = [];
@@ -30725,13 +30753,17 @@ function DiceRoller({
     const starts = currentPositionsRef.current ?? defaultPositions(w, h, clampedCount);
     const frames = simulateDice(w, h, effectiveSize, starts, clampedCount);
     for (let i = 0; i < clampedCount; i++) {
-      writeCubeRotation(
-        i,
-        (Math.random() - 0.5) * 720,
-        (Math.random() - 0.5) * 720,
-        (Math.random() - 0.5) * 720,
-        false
-      );
+      if (sides === 6) {
+        writeCubeRotation(
+          i,
+          (Math.random() - 0.5) * 720,
+          (Math.random() - 0.5) * 720,
+          (Math.random() - 0.5) * 720,
+          false
+        );
+      } else {
+        writeCubeRotation(i, 0, 0, (Math.random() - 0.5) * 720, false);
+      }
       const el = dieWrapperRefs.current[i];
       if (el) el.style.transition = "none";
       const shadow = shadowRefs.current[i];
@@ -30764,18 +30796,47 @@ function DiceRoller({
       }, capturedStep * stepMs);
       timersRef.current.push(timer);
     }
+    if (sides !== 6) {
+      const flickerTicks = 8;
+      const flickerStep = Math.max(60, Math.floor(TUMBLE_MS / flickerTicks));
+      for (let f = 1; f <= flickerTicks; f++) {
+        const t = setTimeout(() => {
+          for (let i = 0; i < clampedCount; i++) {
+            const el = numeralRefs.current[i];
+            if (el)
+              el.textContent = formatDieValue(
+                Math.floor(Math.random() * sides) + 1,
+                sides
+              );
+          }
+        }, f * flickerStep);
+        timersRef.current.push(t);
+      }
+    }
     requestAnimationFrame(() => {
       requestAnimationFrame(() => {
         for (let i = 0; i < clampedCount; i++) {
-          const tgt = SHOW_ROT[vals[i]];
-          const lx = tgt.x + (Math.random() > 0.5 ? 720 : -720);
-          const ly = tgt.y;
-          const lz = (Math.random() > 0.5 ? 1 : -1) * 360;
-          writeCubeRotation(i, lx, ly, lz, true);
+          const tilt = (Math.random() - 0.5) * 18;
+          if (sides === 6) {
+            const tgt = d6LandingRotation(vals[i]);
+            const lx = tgt.x + (Math.random() > 0.5 ? 720 : -720);
+            const ly = tgt.y;
+            const lz = (Math.random() > 0.5 ? 1 : -1) * 360;
+            writeCubeRotation(i, lx, ly, lz, true, tilt);
+          } else {
+            const lz = (Math.random() > 0.5 ? 1 : -1) * 720 + tilt;
+            writeCubeRotation(i, 0, 0, lz, true);
+          }
         }
       });
     });
     const settleTimer = setTimeout(() => {
+      if (sides !== 6) {
+        for (let i = 0; i < clampedCount; i++) {
+          const el = numeralRefs.current[i];
+          if (el) el.textContent = formatDieValue(vals[i], sides);
+        }
+      }
       setResults(vals);
       setRolling(false);
       rollingRef.current = false;
@@ -30788,28 +30849,28 @@ function DiceRoller({
     timersRef.current.push(settleTimer);
   }, [
     clampedCount,
+    sides,
     defaultPositions,
     effectiveSize,
     half,
-    reducedMotion,
     onRoll,
     writeCubeRotation,
     writeDiePosition,
     showHistory,
     historyMax
   ]);
-  useEffect52(() => {
+  useEffect51(() => {
     if (rollRef) rollRef.current = roll;
     return () => {
       if (rollRef && rollRef.current === roll) rollRef.current = null;
     };
   }, [roll, rollRef]);
-  useEffect52(() => {
+  useEffect51(() => {
     if (!autoRoll) return;
     const t = setTimeout(roll, 300);
     return () => clearTimeout(t);
   }, []);
-  useEffect52(
+  useEffect51(
     () => () => {
       timersRef.current.forEach((t) => clearTimeout(t));
       timersRef.current = [];
@@ -30833,7 +30894,7 @@ function DiceRoller({
           {
             ref: arenaRef,
             role: "img",
-            "aria-label": ariaLabel ?? `${clampedCount} dice`,
+            "aria-label": ariaLabel ?? `${clampedCount} ${sides === 6 ? "dice" : `${sides}-sided dice`}`,
             "aria-live": "polite",
             style: {
               position: "relative",
@@ -30896,7 +30957,7 @@ function DiceRoller({
                       transformStyle: "preserve-3d",
                       willChange: "transform"
                     },
-                    children: [1, 2, 3, 4, 5, 6].map((val, fi) => /* @__PURE__ */ jsx113(
+                    children: sides === 6 ? [1, 2, 3, 4, 5, 6].map((val) => /* @__PURE__ */ jsx113(
                       "div",
                       {
                         style: {
@@ -30906,7 +30967,7 @@ function DiceRoller({
                           background: colors.face,
                           border: `1px solid ${colors.faceBorder}`,
                           borderRadius: faceRadius,
-                          transform: faceTransforms[fi],
+                          transform: faceTransformFor(val),
                           transition: "background 0.3s, border-color 0.3s"
                         },
                         children: /* @__PURE__ */ jsx113(
@@ -30920,7 +30981,64 @@ function DiceRoller({
                         )
                       },
                       val
-                    ))
+                    )) : (() => {
+                      const shape = POLY_SHAPES[sides];
+                      const shown = results?.[d] ?? sides;
+                      return /* @__PURE__ */ jsxs86(
+                        "svg",
+                        {
+                          viewBox: "0 0 100 100",
+                          width: "100%",
+                          height: "100%",
+                          style: { display: "block", overflow: "visible" },
+                          "aria-hidden": "true",
+                          children: [
+                            /* @__PURE__ */ jsx113(
+                              "polygon",
+                              {
+                                points: shape.points,
+                                fill: colors.face,
+                                stroke: colors.faceBorder,
+                                strokeWidth: 2.5,
+                                strokeLinejoin: "round",
+                                style: { transition: "fill 0.3s, stroke 0.3s" }
+                              }
+                            ),
+                            /* @__PURE__ */ jsx113(
+                              "polygon",
+                              {
+                                points: shape.points,
+                                fill: "none",
+                                stroke: colors.faceBorder,
+                                strokeWidth: 1.5,
+                                strokeLinejoin: "round",
+                                opacity: 0.55,
+                                transform: "translate(50 50) scale(0.76) translate(-50 -50)"
+                              }
+                            ),
+                            /* @__PURE__ */ jsx113(
+                              "text",
+                              {
+                                ref: getNumeralSetter(d),
+                                x: 50,
+                                y: shape.textY,
+                                textAnchor: "middle",
+                                dominantBaseline: "central",
+                                fontSize: 100 * shape.fontScale,
+                                fontWeight: 800,
+                                fill: colors.pip,
+                                style: {
+                                  fontVariantNumeric: "tabular-nums",
+                                  transition: "fill 0.3s",
+                                  userSelect: "none"
+                                },
+                                children: formatDieValue(shown, sides)
+                              }
+                            )
+                          ]
+                        }
+                      );
+                    })()
                   }
                 )
               ] }, d);
@@ -31053,10 +31171,10 @@ DiceRoller.displayName = "DiceRoller";
 
 // src/components/ui/bracket-generator/index.tsx
 import {
-  useState as useState68,
+  useState as useState67,
   useCallback as useCallback42,
   useRef as useRef41,
-  useEffect as useEffect53,
+  useEffect as useEffect52,
   useMemo as useMemo27,
   useLayoutEffect as useLayoutEffect2
 } from "react";
@@ -31279,7 +31397,7 @@ function computeLayout(rounds, firstRoundCount) {
   };
 }
 function usePanZoom(viewportRef, contentSize, minZoom, maxZoom) {
-  const [transform, setTransform] = useState68({
+  const [transform, setTransform] = useState67({
     x: 0,
     y: 0,
     scale: 1
@@ -31299,7 +31417,7 @@ function usePanZoom(viewportRef, contentSize, minZoom, maxZoom) {
     },
     [contentSize]
   );
-  useEffect53(() => {
+  useEffect52(() => {
     const el = viewportRef.current;
     if (!el) return;
     const onWheel = (e) => {
@@ -31530,12 +31648,12 @@ function BracketGenerator({
   ariaLabel = "Tournament bracket"
 }) {
   const dark = useDarkMode(darkMode);
-  const [bracketState, setBracketState] = useState68({
+  const [bracketState, setBracketState] = useState67({
     matches: [],
     rounds: 0,
     champion: null
   });
-  const [simulating, setSimulating] = useState68(false);
+  const [simulating, setSimulating] = useState67(false);
   const autoRef = useRef41(null);
   const viewportRef = useRef41(null);
   const effectiveParticipants = useMemo27(() => {
@@ -31590,7 +31708,7 @@ function BracketGenerator({
     minZoom,
     maxZoom
   );
-  const [miniMapHidden, setMiniMapHidden] = useState68(false);
+  const [miniMapHidden, setMiniMapHidden] = useState67(false);
   const miniMapDragRef = useRef41(false);
   const resumeRef = useRef41(resumeMatches);
   const hydrateFromResume = useCallback42(() => {
@@ -31724,7 +31842,7 @@ function BracketGenerator({
     []
   );
   const prevBracketStateRef = useRef41(bracketState);
-  useEffect53(() => {
+  useEffect52(() => {
     const prev = prevBracketStateRef.current;
     const next = bracketState;
     if (prev === next) return;
@@ -31748,7 +31866,7 @@ function BracketGenerator({
     [effectiveParticipants, seedingStrategy]
   );
   const seededKeyRef = useRef41(null);
-  useEffect53(() => {
+  useEffect52(() => {
     if (seededKeyRef.current === structuralKey) {
       setBracketState((prev) => {
         if (!prev.matches.length) return prev;
@@ -31779,7 +31897,7 @@ function BracketGenerator({
       seedBracket();
     }
   }, [structuralKey, effectiveParticipants, hydrateFromResume, seedBracket]);
-  useEffect53(() => {
+  useEffect52(() => {
     return () => {
       if (autoRef.current) clearTimeout(autoRef.current);
     };
@@ -31790,7 +31908,7 @@ function BracketGenerator({
       return () => clearTimeout(timer);
     }
   }, [contentSize.w]);
-  useEffect53(() => {
+  useEffect52(() => {
     if (autoSimulate && bracketState.matches.length && !bracketState.champion) {
       const timer = setTimeout(autoPlay, 500);
       return () => clearTimeout(timer);
@@ -32511,10 +32629,10 @@ function BracketGenerator({
 // src/components/ui/coin-flipper/index.tsx
 import {
   useCallback as useCallback43,
-  useEffect as useEffect54,
+  useEffect as useEffect53,
   useMemo as useMemo28,
   useRef as useRef42,
-  useState as useState69
+  useState as useState68
 } from "react";
 import { jsx as jsx115, jsxs as jsxs88 } from "react/jsx-runtime";
 var PRESETS3 = {
@@ -32699,10 +32817,10 @@ function CoinFlipper({
 }) {
   const dark = useDarkMode(darkMode);
   const tc = typeof theme5 === "string" ? PRESETS3[theme5] || PRESETS3.gold : theme5;
-  const [result, setResult] = useState69(null);
-  const [flipping, setFlipping] = useState69(false);
-  const [history, setHistory] = useState69([]);
-  const [stats, setStats] = useState69({ heads: 0, tails: 0 });
+  const [result, setResult] = useState68(null);
+  const [flipping, setFlipping] = useState68(false);
+  const [history, setHistory] = useState68([]);
+  const [stats, setStats] = useState68({ heads: 0, tails: 0 });
   const flipIdRef = useRef42(0);
   const coinRef = useRef42(null);
   const shadowRef = useRef42(null);
@@ -32758,16 +32876,19 @@ function CoinFlipper({
     }, frames.length * stepMs);
     timersRef.current.push(settleTimer);
   }, [flipping, onFlip, historyMax]);
-  useEffect54(() => {
+  useEffect53(() => {
     if (flipRef) flipRef.current = flip;
+    return () => {
+      if (flipRef && flipRef.current === flip) flipRef.current = null;
+    };
   }, [flip, flipRef]);
-  useEffect54(() => {
+  useEffect53(() => {
     if (autoFlip) {
       const timer = setTimeout(flip, 300);
       return () => clearTimeout(timer);
     }
   }, []);
-  useEffect54(() => {
+  useEffect53(() => {
     return () => {
       timersRef.current.forEach(clearTimeout);
     };
@@ -33210,6 +33331,23 @@ import {
   useRef as useRef43,
   useState as useState70
 } from "react";
+
+// src/hooks/web/use-prefers-reduced-motion.ts
+import { useEffect as useEffect54, useState as useState69 } from "react";
+function usePrefersReducedMotion() {
+  const [reduced, setReduced] = useState69(false);
+  useEffect54(() => {
+    if (typeof window === "undefined" || !window.matchMedia) return;
+    const mq = window.matchMedia("(prefers-reduced-motion: reduce)");
+    setReduced(mq.matches);
+    const read = () => setReduced(mq.matches);
+    mq.addEventListener("change", read);
+    return () => mq.removeEventListener("change", read);
+  }, []);
+  return reduced;
+}
+
+// src/components/ui/random-player-picker/index.tsx
 import { Fragment as Fragment31, jsx as jsx116, jsxs as jsxs89 } from "react/jsx-runtime";
 var PRESETS4 = {
   blue: {
@@ -33657,6 +33795,8 @@ function RandomPlayerPicker({
   const particleTimer = useRef43(null);
   const popTimer = useRef43(null);
   const tickInterval = useRef43(null);
+  const pendingPopIdxRef = useRef43(null);
+  const removeWinnersRef = useRef43(removeWinners);
   const tickAudioRef = useRef43(null);
   const winAudioRef = useRef43(null);
   const containerRef = useRef43(null);
@@ -33695,10 +33835,27 @@ function RandomPlayerPicker({
       winAudioRef.current = null;
     };
   }, [winSoundUrl, soundVolume]);
+  useEffect55(() => {
+    removeWinnersRef.current = removeWinners;
+  }, [removeWinners]);
   useEffect55(() => {
     const ids = participants.map((p) => p.id).join("|");
     const structuralChange = ids !== prevIdsRef.current;
     if (structuralChange) {
+      if (winnerTimer.current) {
+        clearTimeout(winnerTimer.current);
+        winnerTimer.current = null;
+      }
+      if (tickInterval.current) {
+        clearTimeout(tickInterval.current);
+        tickInterval.current = null;
+      }
+      if (popTimer.current) {
+        clearTimeout(popTimer.current);
+        popTimer.current = null;
+      }
+      pendingPopIdxRef.current = null;
+      setSpinning(false);
       setPool(participants);
       setHistory([]);
       setWinner(null);
@@ -33755,33 +33912,50 @@ function RandomPlayerPicker({
     [dark]
   );
   const spin = useCallback44(() => {
-    if (spinning || n < 2) return;
+    if (spinning) return;
+    let activePool = pool;
+    if (popTimer.current) {
+      clearTimeout(popTimer.current);
+      popTimer.current = null;
+      const pendingIdx = pendingPopIdxRef.current;
+      pendingPopIdxRef.current = null;
+      if (pendingIdx != null && pendingIdx >= 0 && pendingIdx < pool.length && removeWinnersRef.current) {
+        activePool = pool.filter((_, i) => i !== pendingIdx);
+        setPool(activePool);
+        setWinner(null);
+      }
+    }
+    const activeN = activePool.length;
+    if (activeN < 2) return;
+    const activeAnglePerWedge = 2 * Math.PI / activeN;
+    const activeRotation = rotation;
+    const activeReelY = reelY;
     onSpinStart?.();
-    const winnerIdx = weightedIndex(pool);
+    const winnerIdx = weightedIndex(activePool);
     const minRev = minRevolutions + intensityCfg.revsBoost;
     const maxRev = maxRevolutions + intensityCfg.revsBoost;
     const minFullRevs = Math.ceil(minRev);
     const maxFullRevs = Math.max(minFullRevs, Math.floor(maxRev));
     const revolutions = minFullRevs + Math.floor(Math.random() * (maxFullRevs - minFullRevs + 1));
-    const wedgeMidRad = winnerIdx * anglePerWedge + anglePerWedge / 2;
+    const wedgeMidRad = winnerIdx * activeAnglePerWedge + activeAnglePerWedge / 2;
     const wedgeMidDeg = wedgeMidRad * 180 / Math.PI;
-    const wheelWobble = (Math.random() - 0.5) * (anglePerWedge * 180 / Math.PI) * 0.6;
-    const currentMod = (rotation % 360 + 360) % 360;
+    const wheelWobble = (Math.random() - 0.5) * (activeAnglePerWedge * 180 / Math.PI) * 0.6;
+    const currentMod = (activeRotation % 360 + 360) % 360;
     const targetMod = ((-wedgeMidDeg + wheelWobble) % 360 + 360) % 360;
     let deltaMod = targetMod - currentMod;
     if (deltaMod < 0) deltaMod += 360;
-    const finalRotation = rotation + deltaMod + revolutions * 360;
+    const finalRotation = activeRotation + deltaMod + revolutions * 360;
     const centerOffsetRows = (reelVisibleRows - 1) / 2;
     const centerOffsetPx = centerOffsetRows * reelRowHeight;
     const currentCenterRow = Math.round(
-      (reelY + centerOffsetPx) / reelRowHeight
+      (activeReelY + centerOffsetPx) / reelRowHeight
     );
-    const currentCenterMod = mod(currentCenterRow, n);
-    const targetRowOffset = (winnerIdx - currentCenterMod + n) % n;
-    const reelRevRows = Math.round(revolutions * n);
-    const finalReelY = reelY + (reelRevRows + targetRowOffset) * reelRowHeight;
-    const settledWinnerIdx = mode === "reel" ? reelIndexAtCenter(finalReelY, centerOffsetPx, reelRowHeight, n) : wheelIndexAtPointer(finalRotation, n);
-    const finalWinnerIdx = settledWinnerIdx >= 0 && settledWinnerIdx < pool.length ? settledWinnerIdx : winnerIdx;
+    const currentCenterMod = mod(currentCenterRow, activeN);
+    const targetRowOffset = (winnerIdx - currentCenterMod + activeN) % activeN;
+    const reelRevRows = Math.round(revolutions * activeN);
+    const finalReelY = activeReelY + (reelRevRows + targetRowOffset) * reelRowHeight;
+    const settledWinnerIdx = mode === "reel" ? reelIndexAtCenter(finalReelY, centerOffsetPx, reelRowHeight, activeN) : wheelIndexAtPointer(finalRotation, activeN);
+    const finalWinnerIdx = settledWinnerIdx >= 0 && settledWinnerIdx < activePool.length ? settledWinnerIdx : winnerIdx;
     const effectiveDuration = reducedMotion ? 250 : Math.round(spinDuration * intensityCfg.durationMult);
     setSpinning(true);
     setWinner(null);
@@ -33794,7 +33968,7 @@ function RandomPlayerPicker({
     if ((onTick || tickAudioRef.current) && !reducedMotion) {
       const wedges = mode === "reel" ? Math.max(1, reelRevRows + targetRowOffset) : (() => {
         const totalDelta = deltaMod + revolutions * 360;
-        const wedgeDeg = anglePerWedge * 180 / Math.PI;
+        const wedgeDeg = activeAnglePerWedge * 180 / Math.PI;
         return Math.max(
           1,
           Math.round(totalDelta / Math.max(wedgeDeg, 1))
@@ -33826,7 +34000,7 @@ function RandomPlayerPicker({
       schedule();
     }
     winnerTimer.current = setTimeout(() => {
-      const picked = pool[finalWinnerIdx];
+      const picked = activePool[finalWinnerIdx];
       if (!picked) {
         setSpinning(false);
         return;
@@ -33872,7 +34046,11 @@ function RandomPlayerPicker({
         particleTimer.current = setTimeout(() => setParticles([]), 2400);
       }
       if (removeWinners) {
+        pendingPopIdxRef.current = finalWinnerIdx;
         popTimer.current = setTimeout(() => {
+          popTimer.current = null;
+          pendingPopIdxRef.current = null;
+          if (!removeWinnersRef.current) return;
           setPool((p) => p.filter((_, i) => i !== finalWinnerIdx));
           setWinner(null);
           setRotation(0);
@@ -33883,8 +34061,6 @@ function RandomPlayerPicker({
   }, [
     pool,
     spinning,
-    n,
-    anglePerWedge,
     rotation,
     reelY,
     mode,
@@ -33920,6 +34096,7 @@ function RandomPlayerPicker({
     []
   );
   useEffect55(() => {
+    if (trigger === "external") return;
     const el = containerRef.current;
     if (!el) return;
     const h = (e) => {
@@ -33930,8 +34107,22 @@ function RandomPlayerPicker({
     };
     el.addEventListener("keydown", h);
     return () => el.removeEventListener("keydown", h);
-  }, [spin]);
+  }, [spin, trigger]);
   const reset = useCallback44(() => {
+    if (winnerTimer.current) {
+      clearTimeout(winnerTimer.current);
+      winnerTimer.current = null;
+    }
+    if (tickInterval.current) {
+      clearTimeout(tickInterval.current);
+      tickInterval.current = null;
+    }
+    if (popTimer.current) {
+      clearTimeout(popTimer.current);
+      popTimer.current = null;
+    }
+    pendingPopIdxRef.current = null;
+    setSpinning(false);
     setPool(participants);
     setHistory([]);
     setWinner(null);
@@ -38404,27 +38595,28 @@ function GameTimer({
     const now = performance.now();
     const delta = now - lastTickRef.current;
     lastTickRef.current = now;
-    setElapsedMs((prev) => {
-      const next = prev + delta;
-      if (mode === "countdown" && next >= durationMs) {
-        setRunning(false);
-        setCompleted(true);
-        onComplete?.();
-        return durationMs;
+    const next = elapsedRef.current + delta;
+    if (mode === "countdown" && next >= durationMs) {
+      elapsedRef.current = durationMs;
+      setElapsedMs(durationMs);
+      setRunning(false);
+      setCompleted(true);
+      onComplete?.();
+      return;
+    }
+    if (mode === "countdown") {
+      const secLeft = Math.ceil((durationMs - next) / 1e3);
+      if (secLeft <= warningAt && !warningFiredRef.current) {
+        warningFiredRef.current = true;
+        onWarning?.();
       }
-      if (mode === "countdown") {
-        const secLeft = Math.ceil((durationMs - next) / 1e3);
-        if (secLeft <= warningAt && !warningFiredRef.current) {
-          warningFiredRef.current = true;
-          onWarning?.();
-        }
-        if (secLeft <= dangerAt && !dangerFiredRef.current) {
-          dangerFiredRef.current = true;
-          onDanger?.();
-        }
+      if (secLeft <= dangerAt && !dangerFiredRef.current) {
+        dangerFiredRef.current = true;
+        onDanger?.();
       }
-      return next;
-    });
+    }
+    elapsedRef.current = next;
+    setElapsedMs(next);
     rafRef.current = requestAnimationFrame(tick);
   }, [mode, durationMs, warningAt, dangerAt, onComplete, onWarning, onDanger]);
   useEffect59(() => {
@@ -38445,6 +38637,7 @@ function GameTimer({
   }, []);
   const reset = useCallback48(() => {
     setRunning(false);
+    elapsedRef.current = 0;
     setElapsedMs(0);
     setCompleted(false);
     setLaps([]);
@@ -40401,6 +40594,8 @@ function RoundRobinScheduler({
   theme: theme5 = "slate",
   darkMode,
   minTeams = 3,
+  maxTeams,
+  nameMaxLength,
   defaultTeams = [],
   resumeRounds,
   onTeamsChange,
@@ -40423,39 +40618,41 @@ function RoundRobinScheduler({
   useEffect62(() => {
     onTeamsChange?.(teams);
   }, [teams, onTeamsChange]);
-  const addTeams = useCallback51((raw) => {
-    const names = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-    if (names.length === 0) return;
-    setTeams((prev) => {
+  const mergeNames = useCallback51(
+    (prev, incoming) => {
       const existing = new Set(prev.map((t) => t.toLowerCase()));
       const next = [...prev];
-      for (const name of names) {
-        if (!existing.has(name.toLowerCase())) {
-          existing.add(name.toLowerCase());
-          next.push(name);
-        }
-      }
-      return next;
-    });
-    setInput("");
-    setRounds([]);
-  }, []);
-  const importTeams = useCallback51((incoming) => {
-    if (incoming.length === 0) return;
-    setTeams((prev) => {
-      const existing = new Set(prev.map((t) => t.toLowerCase()));
-      const next = [...prev];
-      for (const name of incoming) {
+      for (const rawName of incoming) {
+        if (maxTeams != null && next.length >= maxTeams) break;
+        const name = nameMaxLength != null ? rawName.slice(0, nameMaxLength) : rawName;
         const key = name.toLowerCase();
-        if (!existing.has(key)) {
+        if (name.length > 0 && !existing.has(key)) {
           existing.add(key);
           next.push(name);
         }
       }
       return next;
-    });
-    setRounds([]);
-  }, []);
+    },
+    [maxTeams, nameMaxLength]
+  );
+  const addTeams = useCallback51(
+    (raw) => {
+      const names = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+      if (names.length === 0) return;
+      setTeams((prev) => mergeNames(prev, names));
+      setInput("");
+      setRounds([]);
+    },
+    [mergeNames]
+  );
+  const importTeams = useCallback51(
+    (incoming) => {
+      if (incoming.length === 0) return;
+      setTeams((prev) => mergeNames(prev, incoming));
+      setRounds([]);
+    },
+    [mergeNames]
+  );
   const handleKeyDown = useCallback51(
     (e) => {
       if (e.key === "Enter") {
@@ -40949,6 +41146,8 @@ function Scoreboard({
   onTeamsChange,
   onRoundAdvance,
   onNewGame,
+  onReset,
+  nameMaxLength,
   labels,
   ariaLabel = "Scoreboard",
   className
@@ -41023,7 +41222,8 @@ function Scoreboard({
     setRound(1);
     setHistory([]);
     setHistoryOpen(false);
-  }, []);
+    onReset?.();
+  }, [onReset]);
   const newGame = useCallback52(() => {
     setTeams(createDefaultTeams(seedCount, L.teamNamePrefix));
     setRound(1);
@@ -41245,6 +41445,7 @@ function Scoreboard({
                     {
                       type: "text",
                       value: team.name,
+                      maxLength: nameMaxLength,
                       onChange: (e) => updateName(index, e.target.value),
                       style: nameInputStyle,
                       "aria-label": `Team ${index + 1} name`
@@ -43343,6 +43544,7 @@ export {
   CommentSystem,
   Container,
   ConversionKPI,
+  D6_FACE_PLACEMENTS,
   DashboardGrid,
   DashboardLayout,
   DashboardWidget,
@@ -43583,6 +43785,7 @@ export {
   createFormStore,
   createOptimizedStore,
   cssAnimations,
+  d6LandingRotation,
   dailyTrendingConfig,
   detectAuthProvider,
   detectDelimiter,