@digilogiclabs/saas-factory-ui 2.3.0 → 2.5.0

package/dist/web/index.js

@@ -30225,7 +30225,7 @@ function TiltCard({
 }
 
 // src/components/ui/dice-roller/index.tsx
-var import_react70 = require("react");
+var import_react69 = require("react");
 
 // src/hooks/web/use-dark-mode.ts
 var import_react68 = require("react");
@@ -30274,21 +30274,6 @@ function useDarkMode(forced) {
   return dark;
 }
 
-// src/hooks/web/use-prefers-reduced-motion.ts
-var import_react69 = require("react");
-function usePrefersReducedMotion() {
-  const [reduced, setReduced] = (0, import_react69.useState)(false);
-  (0, import_react69.useEffect)(() => {
-    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
 var import_jsx_runtime113 = require("react/jsx-runtime");
 var PRESETS = {
@@ -30507,8 +30492,8 @@ function simulateDice(arenaW, arenaH, diceSize, starts, numDice) {
   return frames;
 }
 function useArenaBounds(ref) {
-  const [bounds, setBounds] = (0, import_react70.useState)({ w: 400, h: 260 });
-  (0, import_react70.useEffect)(() => {
+  const [bounds, setBounds] = (0, import_react69.useState)({ w: 400, h: 260 });
+  (0, import_react69.useEffect)(() => {
     if (!ref.current) return;
     const el = ref.current;
     const update = () => setBounds({ w: el.offsetWidth, h: el.offsetHeight });
@@ -30563,19 +30548,18 @@ function DiceRoller({
 }) {
   const clampedCount = Math.max(1, Math.min(MAX_COUNT, count2));
   const dark = useDarkMode(darkMode);
-  const reducedMotion = usePrefersReducedMotion();
-  const [rolling, setRolling] = (0, import_react70.useState)(false);
-  const [results, setResults] = (0, import_react70.useState)(null);
-  const [history, setHistory] = (0, import_react70.useState)([]);
-  const dieWrapperRefs = (0, import_react70.useRef)([]);
-  const cubeRefs = (0, import_react70.useRef)([]);
-  const shadowRefs = (0, import_react70.useRef)([]);
-  const numeralRefs = (0, import_react70.useRef)([]);
-  const currentPositionsRef = (0, import_react70.useRef)(null);
-  const rollingRef = (0, import_react70.useRef)(false);
-  const dieSetters = (0, import_react70.useRef)([]);
-  const cubeSetters = (0, import_react70.useRef)([]);
-  const shadowSetters = (0, import_react70.useRef)([]);
+  const [rolling, setRolling] = (0, import_react69.useState)(false);
+  const [results, setResults] = (0, import_react69.useState)(null);
+  const [history, setHistory] = (0, import_react69.useState)([]);
+  const dieWrapperRefs = (0, import_react69.useRef)([]);
+  const cubeRefs = (0, import_react69.useRef)([]);
+  const shadowRefs = (0, import_react69.useRef)([]);
+  const numeralRefs = (0, import_react69.useRef)([]);
+  const currentPositionsRef = (0, import_react69.useRef)(null);
+  const rollingRef = (0, import_react69.useRef)(false);
+  const dieSetters = (0, import_react69.useRef)([]);
+  const cubeSetters = (0, import_react69.useRef)([]);
+  const shadowSetters = (0, import_react69.useRef)([]);
   const getDieSetter = (i) => {
     if (!dieSetters.current[i]) {
       dieSetters.current[i] = (el) => {
@@ -30600,7 +30584,7 @@ function DiceRoller({
     }
     return shadowSetters.current[i];
   };
-  const numeralSetters = (0, import_react70.useRef)([]);
+  const numeralSetters = (0, import_react69.useRef)([]);
   const getNumeralSetter = (i) => {
     if (!numeralSetters.current[i]) {
       numeralSetters.current[i] = (el) => {
@@ -30609,11 +30593,11 @@ function DiceRoller({
     }
     return numeralSetters.current[i];
   };
-  const timersRef = (0, import_react70.useRef)([]);
-  const rafHandleRef = (0, import_react70.useRef)(null);
-  const arenaRef = (0, import_react70.useRef)(null);
+  const timersRef = (0, import_react69.useRef)([]);
+  const rafHandleRef = (0, import_react69.useRef)(null);
+  const arenaRef = (0, import_react69.useRef)(null);
   const arena = useArenaBounds(arenaRef);
-  const colors = (0, import_react70.useMemo)(() => {
+  const colors = (0, import_react69.useMemo)(() => {
     if (typeof theme5 === "object") {
       const pipL = theme5.pip;
       const pipD = theme5.pipDark ?? theme5.pip;
@@ -30650,7 +30634,7 @@ function DiceRoller({
       chipDim: dark ? "#3a4358" : "#94a3b8"
     };
   }, [theme5, dark]);
-  const effectiveSize = (0, import_react70.useMemo)(() => {
+  const effectiveSize = (0, import_react69.useMemo)(() => {
     if (!responsive2) return size;
     const needed = clampedCount * size * 1.6;
     if (arena.w >= needed || arena.w === 0) return size;
@@ -30661,7 +30645,7 @@ 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 faceTransformFor = (0, import_react70.useCallback)(
+  const faceTransformFor = (0, import_react69.useCallback)(
     (value) => {
       const p = D6_FACE_PLACEMENTS[value];
       const parts = [];
@@ -30672,14 +30656,14 @@ function DiceRoller({
     },
     [half]
   );
-  const defaultPositions = (0, import_react70.useCallback)(
+  const defaultPositions = (0, import_react69.useCallback)(
     (w, h, n) => Array.from({ length: n }, (_, i) => ({
       x: (i + 1) * w / (n + 1),
       y: h / 2
     })),
     []
   );
-  const writeDiePosition = (0, import_react70.useCallback)(
+  const writeDiePosition = (0, import_react69.useCallback)(
     (i, x, y, sx = 1, sy = 1) => {
       const el = dieWrapperRefs.current[i];
       if (!el) return;
@@ -30690,7 +30674,7 @@ function DiceRoller({
     },
     [half]
   );
-  const writeCubeRotation = (0, import_react70.useCallback)(
+  const writeCubeRotation = (0, import_react69.useCallback)(
     (i, rx, ry, rz, withTransition, tiltZ = 0) => {
       const el = cubeRefs.current[i];
       if (!el) return;
@@ -30699,7 +30683,15 @@ function DiceRoller({
     },
     []
   );
-  (0, import_react70.useEffect)(() => {
+  (0, import_react69.useEffect)(() => {
+    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;
@@ -30732,10 +30724,10 @@ function DiceRoller({
     defaultPositions,
     half
   ]);
-  (0, import_react70.useEffect)(() => {
+  (0, import_react69.useEffect)(() => {
     setHistory([]);
   }, [sides]);
-  const roll = (0, import_react70.useCallback)(() => {
+  const roll = (0, import_react69.useCallback)(() => {
     if (rollingRef.current) return;
     rollingRef.current = true;
     setRolling(true);
@@ -30856,25 +30848,24 @@ function DiceRoller({
     defaultPositions,
     effectiveSize,
     half,
-    reducedMotion,
     onRoll,
     writeCubeRotation,
     writeDiePosition,
     showHistory,
     historyMax
   ]);
-  (0, import_react70.useEffect)(() => {
+  (0, import_react69.useEffect)(() => {
     if (rollRef) rollRef.current = roll;
     return () => {
       if (rollRef && rollRef.current === roll) rollRef.current = null;
     };
   }, [roll, rollRef]);
-  (0, import_react70.useEffect)(() => {
+  (0, import_react69.useEffect)(() => {
     if (!autoRoll) return;
     const t = setTimeout(roll, 300);
     return () => clearTimeout(t);
   }, []);
-  (0, import_react70.useEffect)(
+  (0, import_react69.useEffect)(
     () => () => {
       timersRef.current.forEach((t) => clearTimeout(t));
       timersRef.current = [];
@@ -31174,7 +31165,7 @@ function DiceRoller({
 DiceRoller.displayName = "DiceRoller";
 
 // src/components/ui/bracket-generator/index.tsx
-var import_react71 = require("react");
+var import_react70 = require("react");
 
 // src/utils/array.ts
 function shuffle(arr) {
@@ -31394,15 +31385,15 @@ function computeLayout(rounds, firstRoundCount) {
   };
 }
 function usePanZoom(viewportRef, contentSize, minZoom, maxZoom) {
-  const [transform, setTransform] = (0, import_react71.useState)({
+  const [transform, setTransform] = (0, import_react70.useState)({
     x: 0,
     y: 0,
     scale: 1
   });
-  const isDragging = (0, import_react71.useRef)(false);
-  const dragStart = (0, import_react71.useRef)({ x: 0, y: 0 });
-  const pinchRef = (0, import_react71.useRef)(null);
-  const clampTransform = (0, import_react71.useCallback)(
+  const isDragging = (0, import_react70.useRef)(false);
+  const dragStart = (0, import_react70.useRef)({ x: 0, y: 0 });
+  const pinchRef = (0, import_react70.useRef)(null);
+  const clampTransform = (0, import_react70.useCallback)(
     (t, vw, vh) => {
       const sw = contentSize.w * t.scale;
       const sh = contentSize.h * t.scale;
@@ -31414,7 +31405,7 @@ function usePanZoom(viewportRef, contentSize, minZoom, maxZoom) {
     },
     [contentSize]
   );
-  (0, import_react71.useEffect)(() => {
+  (0, import_react70.useEffect)(() => {
     const el = viewportRef.current;
     if (!el) return;
     const onWheel = (e) => {
@@ -31439,7 +31430,7 @@ function usePanZoom(viewportRef, contentSize, minZoom, maxZoom) {
     el.addEventListener("wheel", onWheel, { passive: false });
     return () => el.removeEventListener("wheel", onWheel);
   }, [viewportRef, minZoom, maxZoom, clampTransform]);
-  const onPointerDown = (0, import_react71.useCallback)(
+  const onPointerDown = (0, import_react70.useCallback)(
     (e) => {
       if (e.target.closest("[data-no-pan]")) return;
       isDragging.current = true;
@@ -31452,7 +31443,7 @@ function usePanZoom(viewportRef, contentSize, minZoom, maxZoom) {
     },
     [transform]
   );
-  const onPointerMove = (0, import_react71.useCallback)(
+  const onPointerMove = (0, import_react70.useCallback)(
     (e) => {
       if (!isDragging.current) return;
       const el = viewportRef.current;
@@ -31472,11 +31463,11 @@ function usePanZoom(viewportRef, contentSize, minZoom, maxZoom) {
     },
     [viewportRef, clampTransform]
   );
-  const onPointerUp = (0, import_react71.useCallback)((e) => {
+  const onPointerUp = (0, import_react70.useCallback)((e) => {
     isDragging.current = false;
     e.currentTarget.style.cursor = "grab";
   }, []);
-  const onTouchStart = (0, import_react71.useCallback)(
+  const onTouchStart = (0, import_react70.useCallback)(
     (e) => {
       if (e.touches.length === 2) {
         const [t1, t2] = [e.touches[0], e.touches[1]];
@@ -31496,7 +31487,7 @@ function usePanZoom(viewportRef, contentSize, minZoom, maxZoom) {
     },
     [transform]
   );
-  const onTouchMove = (0, import_react71.useCallback)(
+  const onTouchMove = (0, import_react70.useCallback)(
     (e) => {
       if (e.touches.length === 2 && pinchRef.current) {
         e.preventDefault();
@@ -31533,10 +31524,10 @@ function usePanZoom(viewportRef, contentSize, minZoom, maxZoom) {
     },
     [viewportRef, minZoom, maxZoom, clampTransform]
   );
-  const onTouchEnd = (0, import_react71.useCallback)(() => {
+  const onTouchEnd = (0, import_react70.useCallback)(() => {
     pinchRef.current = null;
   }, []);
-  const zoomBy = (0, import_react71.useCallback)(
+  const zoomBy = (0, import_react70.useCallback)(
     (factor) => {
       const el = viewportRef.current;
       if (!el) return;
@@ -31555,7 +31546,7 @@ function usePanZoom(viewportRef, contentSize, minZoom, maxZoom) {
     },
     [viewportRef, minZoom, maxZoom, clampTransform]
   );
-  const fit = (0, import_react71.useCallback)(() => {
+  const fit = (0, import_react70.useCallback)(() => {
     const el = viewportRef.current;
     if (!el || !contentSize.w) return;
     const rect = el.getBoundingClientRect();
@@ -31569,10 +31560,10 @@ function usePanZoom(viewportRef, contentSize, minZoom, maxZoom) {
       scale
     });
   }, [viewportRef, contentSize, minZoom, maxZoom]);
-  const reset = (0, import_react71.useCallback)(() => {
+  const reset = (0, import_react70.useCallback)(() => {
     setTransform({ x: 40, y: 40, scale: 1 });
   }, []);
-  const panTo = (0, import_react71.useCallback)(
+  const panTo = (0, import_react70.useCallback)(
     (contentX, contentY) => {
       const el = viewportRef.current;
       if (!el) return;
@@ -31645,15 +31636,15 @@ function BracketGenerator({
   ariaLabel = "Tournament bracket"
 }) {
   const dark = useDarkMode(darkMode);
-  const [bracketState, setBracketState] = (0, import_react71.useState)({
+  const [bracketState, setBracketState] = (0, import_react70.useState)({
     matches: [],
     rounds: 0,
     champion: null
   });
-  const [simulating, setSimulating] = (0, import_react71.useState)(false);
-  const autoRef = (0, import_react71.useRef)(null);
-  const viewportRef = (0, import_react71.useRef)(null);
-  const effectiveParticipants = (0, import_react71.useMemo)(() => {
+  const [simulating, setSimulating] = (0, import_react70.useState)(false);
+  const autoRef = (0, import_react70.useRef)(null);
+  const viewportRef = (0, import_react70.useRef)(null);
+  const effectiveParticipants = (0, import_react70.useMemo)(() => {
     if (participantsProp?.length) {
       return padToSize(
         participantsProp.map((p, i) => ({
@@ -31672,7 +31663,7 @@ function BracketGenerator({
     }));
   }, [participantsProp, size]);
   const preset = typeof theme5 === "string" ? PRESETS2[theme5] || PRESETS2.blue : null;
-  const themeColors = (0, import_react71.useMemo)(() => {
+  const themeColors = (0, import_react70.useMemo)(() => {
     if (typeof theme5 === "object") return theme5;
     const p = preset;
     return {
@@ -31681,9 +31672,9 @@ function BracketGenerator({
       color: p.color
     };
   }, [theme5, dark, preset]);
-  const colors = (0, import_react71.useMemo)(() => buildColorTokens(dark), [dark]);
+  const colors = (0, import_react70.useMemo)(() => buildColorTokens(dark), [dark]);
   const roundLabels = ROUND_NAMES[effectiveParticipants.length] || [];
-  const layout = (0, import_react71.useMemo)(() => {
+  const layout = (0, import_react70.useMemo)(() => {
     if (!bracketState.rounds)
       return {
         positions: {},
@@ -31692,7 +31683,7 @@ function BracketGenerator({
       };
     return computeLayout(bracketState.rounds, effectiveParticipants.length / 2);
   }, [bracketState.rounds, effectiveParticipants.length]);
-  const contentSize = (0, import_react71.useMemo)(
+  const contentSize = (0, import_react70.useMemo)(
     () => ({
       w: layout.totalW + CANVAS_PAD * 2,
       h: layout.totalH + CANVAS_PAD * 2
@@ -31705,10 +31696,10 @@ function BracketGenerator({
     minZoom,
     maxZoom
   );
-  const [miniMapHidden, setMiniMapHidden] = (0, import_react71.useState)(false);
-  const miniMapDragRef = (0, import_react71.useRef)(false);
-  const resumeRef = (0, import_react71.useRef)(resumeMatches);
-  const hydrateFromResume = (0, import_react71.useCallback)(() => {
+  const [miniMapHidden, setMiniMapHidden] = (0, import_react70.useState)(false);
+  const miniMapDragRef = (0, import_react70.useRef)(false);
+  const resumeRef = (0, import_react70.useRef)(resumeMatches);
+  const hydrateFromResume = (0, import_react70.useCallback)(() => {
     const resume = resumeRef.current;
     if (!resume?.length) return null;
     const n = effectiveParticipants.length;
@@ -31748,7 +31739,7 @@ function BracketGenerator({
     const finalMatch = matches.find((m) => m.round === rounds - 1);
     return { matches, rounds, champion: finalMatch?.winner ?? null };
   }, [effectiveParticipants]);
-  const seedBracket = (0, import_react71.useCallback)(() => {
+  const seedBracket = (0, import_react70.useCallback)(() => {
     const { matches, rounds } = buildBracket(
       effectiveParticipants,
       seedingStrategy
@@ -31771,7 +31762,7 @@ function BracketGenerator({
     };
     setBracketState(newState);
   }, [effectiveParticipants, seedingStrategy]);
-  const simulateNext = (0, import_react71.useCallback)(() => {
+  const simulateNext = (0, import_react70.useCallback)(() => {
     setBracketState((prev) => {
       const next = prev.matches.find((m) => m.a && m.b && !m.winner);
       if (!next) return prev;
@@ -31786,7 +31777,7 @@ function BracketGenerator({
       return { ...prev, matches, champion };
     });
   }, []);
-  const autoPlay = (0, import_react71.useCallback)(() => {
+  const autoPlay = (0, import_react70.useCallback)(() => {
     if (simulating) {
       if (autoRef.current) clearTimeout(autoRef.current);
       setSimulating(false);
@@ -31815,7 +31806,7 @@ function BracketGenerator({
     };
     tick();
   }, [simulating, simulateDelayMs]);
-  const advanceWinner = (0, import_react71.useCallback)(
+  const advanceWinner = (0, import_react70.useCallback)(
     (matchId, winnerSlot) => {
       setBracketState((prev) => {
         const m = prev.matches.find((x) => x.id === matchId);
@@ -31838,8 +31829,8 @@ function BracketGenerator({
     },
     []
   );
-  const prevBracketStateRef = (0, import_react71.useRef)(bracketState);
-  (0, import_react71.useEffect)(() => {
+  const prevBracketStateRef = (0, import_react70.useRef)(bracketState);
+  (0, import_react70.useEffect)(() => {
     const prev = prevBracketStateRef.current;
     const next = bracketState;
     if (prev === next) return;
@@ -31858,12 +31849,12 @@ function BracketGenerator({
     onStateChange?.(next);
     prevBracketStateRef.current = next;
   }, [bracketState, onMatchComplete, onChampion, onStateChange]);
-  const structuralKey = (0, import_react71.useMemo)(
+  const structuralKey = (0, import_react70.useMemo)(
     () => `${seedingStrategy}|${effectiveParticipants.map((p) => `${p.id}:${p.seed ?? ""}`).join(",")}`,
     [effectiveParticipants, seedingStrategy]
   );
-  const seededKeyRef = (0, import_react71.useRef)(null);
-  (0, import_react71.useEffect)(() => {
+  const seededKeyRef = (0, import_react70.useRef)(null);
+  (0, import_react70.useEffect)(() => {
     if (seededKeyRef.current === structuralKey) {
       setBracketState((prev) => {
         if (!prev.matches.length) return prev;
@@ -31894,24 +31885,24 @@ function BracketGenerator({
       seedBracket();
     }
   }, [structuralKey, effectiveParticipants, hydrateFromResume, seedBracket]);
-  (0, import_react71.useEffect)(() => {
+  (0, import_react70.useEffect)(() => {
     return () => {
       if (autoRef.current) clearTimeout(autoRef.current);
     };
   }, []);
-  (0, import_react71.useLayoutEffect)(() => {
+  (0, import_react70.useLayoutEffect)(() => {
     if (contentSize.w > 0) {
       const timer = setTimeout(fit, 50);
       return () => clearTimeout(timer);
     }
   }, [contentSize.w]);
-  (0, import_react71.useEffect)(() => {
+  (0, import_react70.useEffect)(() => {
     if (autoSimulate && bracketState.matches.length && !bracketState.champion) {
       const timer = setTimeout(autoPlay, 500);
       return () => clearTimeout(timer);
     }
   }, [autoSimulate]);
-  const stats = (0, import_react71.useMemo)(() => {
+  const stats = (0, import_react70.useMemo)(() => {
     const done = bracketState.matches.filter((m) => m.winner).length;
     const total = bracketState.matches.length;
     const remaining = bracketState.matches.filter(
@@ -31919,7 +31910,7 @@ function BracketGenerator({
     ).length;
     return { done, total, remaining };
   }, [bracketState]);
-  const connectorPaths = (0, import_react71.useMemo)(() => {
+  const connectorPaths = (0, import_react70.useMemo)(() => {
     const paths = [];
     bracketState.matches.forEach((m) => {
       if (m.round >= bracketState.rounds - 1) return;
@@ -32624,7 +32615,7 @@ function BracketGenerator({
 }
 
 // src/components/ui/coin-flipper/index.tsx
-var import_react72 = require("react");
+var import_react71 = require("react");
 var import_jsx_runtime115 = require("react/jsx-runtime");
 var PRESETS3 = {
   gold: {
@@ -32808,15 +32799,15 @@ function CoinFlipper({
 }) {
   const dark = useDarkMode(darkMode);
   const tc = typeof theme5 === "string" ? PRESETS3[theme5] || PRESETS3.gold : theme5;
-  const [result, setResult] = (0, import_react72.useState)(null);
-  const [flipping, setFlipping] = (0, import_react72.useState)(false);
-  const [history, setHistory] = (0, import_react72.useState)([]);
-  const [stats, setStats] = (0, import_react72.useState)({ heads: 0, tails: 0 });
-  const flipIdRef = (0, import_react72.useRef)(0);
-  const coinRef = (0, import_react72.useRef)(null);
-  const shadowRef = (0, import_react72.useRef)(null);
-  const timersRef = (0, import_react72.useRef)([]);
-  const colors = (0, import_react72.useMemo)(
+  const [result, setResult] = (0, import_react71.useState)(null);
+  const [flipping, setFlipping] = (0, import_react71.useState)(false);
+  const [history, setHistory] = (0, import_react71.useState)([]);
+  const [stats, setStats] = (0, import_react71.useState)({ heads: 0, tails: 0 });
+  const flipIdRef = (0, import_react71.useRef)(0);
+  const coinRef = (0, import_react71.useRef)(null);
+  const shadowRef = (0, import_react71.useRef)(null);
+  const timersRef = (0, import_react71.useRef)([]);
+  const colors = (0, import_react71.useMemo)(
     () => ({
       bg: dark ? "#0f1117" : "#f8fafc",
       surface: dark ? "#1a1d27" : "#ffffff",
@@ -32827,7 +32818,7 @@ function CoinFlipper({
     }),
     [dark]
   );
-  const flip = (0, import_react72.useCallback)(() => {
+  const flip = (0, import_react71.useCallback)(() => {
     if (flipping) return;
     setFlipping(true);
     const outcome = Math.random() < 0.5 ? "heads" : "tails";
@@ -32867,16 +32858,19 @@ function CoinFlipper({
     }, frames.length * stepMs);
     timersRef.current.push(settleTimer);
   }, [flipping, onFlip, historyMax]);
-  (0, import_react72.useEffect)(() => {
+  (0, import_react71.useEffect)(() => {
     if (flipRef) flipRef.current = flip;
+    return () => {
+      if (flipRef && flipRef.current === flip) flipRef.current = null;
+    };
   }, [flip, flipRef]);
-  (0, import_react72.useEffect)(() => {
+  (0, import_react71.useEffect)(() => {
     if (autoFlip) {
       const timer = setTimeout(flip, 300);
       return () => clearTimeout(timer);
     }
   }, []);
-  (0, import_react72.useEffect)(() => {
+  (0, import_react71.useEffect)(() => {
     return () => {
       timersRef.current.forEach(clearTimeout);
     };
@@ -33313,6 +33307,23 @@ function CoinFlipper({
 
 // src/components/ui/random-player-picker/index.tsx
 var import_react73 = require("react");
+
+// src/hooks/web/use-prefers-reduced-motion.ts
+var import_react72 = require("react");
+function usePrefersReducedMotion() {
+  const [reduced, setReduced] = (0, import_react72.useState)(false);
+  (0, import_react72.useEffect)(() => {
+    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
 var import_jsx_runtime116 = require("react/jsx-runtime");
 var PRESETS4 = {
   blue: {
@@ -33370,6 +33381,11 @@ var WEDGE_PALETTE = [
 ];
 var DEFAULT_EASING = "cubic-bezier(0.25, 0.46, 0.45, 0.94)";
 var DRAMATIC_EASING = "cubic-bezier(0.39, 0.575, 0.565, 1)";
+var PHYSICS_DECAY_K = 4;
+function physicsRampDown(t) {
+  return (1 - Math.exp(-PHYSICS_DECAY_K * t)) / (1 - Math.exp(-PHYSICS_DECAY_K));
+}
+var REEL_LEAD_IN = 32;
 var INTENSITY_CONFIG = {
   subtle: {
     particles: 14,
@@ -33441,6 +33457,9 @@ function ReelStage({
   winner,
   spinning,
   reelY,
+  displayY,
+  cssTransition,
+  tapeRef,
   reelVisibleRows,
   reelRowHeight,
   size,
@@ -33464,17 +33483,16 @@ function ReelStage({
   const stripHeight = reelVisibleRows * reelRowHeight;
   const centerOffsetPx = (reelVisibleRows - 1) / 2 * reelRowHeight;
   const P = pool.length;
-  const leadIn = 32;
   const tapeRows = Math.max(
-    reelVisibleRows + leadIn + 1,
-    Math.ceil((reelY + stripHeight) / reelRowHeight) + leadIn + 1
+    reelVisibleRows + REEL_LEAD_IN + 1,
+    Math.ceil((reelY + stripHeight) / reelRowHeight) + REEL_LEAD_IN + 1
   );
   const tape = Array.from({ length: tapeRows }, (_, i) => {
-    const poolIdx = P === 0 ? 0 : ((i - leadIn) % P + P) % P;
+    const poolIdx = P === 0 ? 0 : ((i - REEL_LEAD_IN) % P + P) % P;
     return pool[poolIdx];
   });
-  const effectiveY = reelY + leadIn * reelRowHeight;
-  const transition = spinning ? `transform ${reducedMotion ? 250 : Math.round(spinDuration * intensityCfg.durationMult)}ms ${intensityCfg.easing}` : "none";
+  const effectiveY = displayY + REEL_LEAD_IN * reelRowHeight;
+  const transition = spinning && cssTransition ? `transform ${reducedMotion ? 250 : Math.round(spinDuration * intensityCfg.durationMult)}ms ${intensityCfg.easing}` : "none";
   return /* @__PURE__ */ (0, import_jsx_runtime116.jsxs)(
     "div",
     {
@@ -33519,6 +33537,7 @@ function ReelStage({
               ) : /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(
                 "div",
                 {
+                  ref: tapeRef,
                   "aria-hidden": "true",
                   style: {
                     position: "absolute",
@@ -33734,6 +33753,9 @@ function RandomPlayerPicker({
   showStats = true,
   renderWinner,
   spinRef,
+  resetRef,
+  onPoolChange,
+  draftCompleteCaption = "Draft complete \u2014 reset to spin again",
   intensity = "normal",
   enableHaptics = false,
   tickSoundUrl,
@@ -33748,6 +33770,7 @@ function RandomPlayerPicker({
   const dark = useDarkMode(darkMode);
   const reducedMotion = usePrefersReducedMotion();
   const intensityCfg = INTENSITY_CONFIG[intensity];
+  const physicsDriven = intensity === "dramatic" && !reducedMotion;
   const [pool, setPool] = (0, import_react73.useState)(participants);
   const [rotation, setRotation] = (0, import_react73.useState)(0);
   const [reelY, setReelY] = (0, import_react73.useState)(0);
@@ -33760,10 +33783,17 @@ function RandomPlayerPicker({
   const particleTimer = (0, import_react73.useRef)(null);
   const popTimer = (0, import_react73.useRef)(null);
   const tickInterval = (0, import_react73.useRef)(null);
+  const pendingPopIdxRef = (0, import_react73.useRef)(null);
+  const removeWinnersRef = (0, import_react73.useRef)(removeWinners);
   const tickAudioRef = (0, import_react73.useRef)(null);
   const winAudioRef = (0, import_react73.useRef)(null);
   const containerRef = (0, import_react73.useRef)(null);
   const prevIdsRef = (0, import_react73.useRef)("");
+  const wheelSvgRef = (0, import_react73.useRef)(null);
+  const reelTapeRef = (0, import_react73.useRef)(null);
+  const rafRef = (0, import_react73.useRef)(null);
+  const visualRotationRef = (0, import_react73.useRef)(null);
+  const visualReelYRef = (0, import_react73.useRef)(null);
   (0, import_react73.useEffect)(() => {
     if (typeof window === "undefined" || !tickSoundUrl) {
       tickAudioRef.current = null;
@@ -33798,10 +33828,33 @@ function RandomPlayerPicker({
       winAudioRef.current = null;
     };
   }, [winSoundUrl, soundVolume]);
+  (0, import_react73.useEffect)(() => {
+    removeWinnersRef.current = removeWinners;
+  }, [removeWinners]);
   (0, import_react73.useEffect)(() => {
     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;
+      }
+      if (rafRef.current) {
+        cancelAnimationFrame(rafRef.current);
+        rafRef.current = null;
+      }
+      visualRotationRef.current = null;
+      visualReelYRef.current = null;
+      pendingPopIdxRef.current = null;
+      setSpinning(false);
       setPool(participants);
       setHistory([]);
       setWinner(null);
@@ -33858,33 +33911,50 @@ function RandomPlayerPicker({
     [dark]
   );
   const spin = (0, import_react73.useCallback)(() => {
-    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);
@@ -33894,10 +33964,59 @@ function RandomPlayerPicker({
     } else {
       setRotation(finalRotation);
     }
-    if ((onTick || tickAudioRef.current) && !reducedMotion) {
+    const fireTick = () => {
+      onTick?.();
+      const ta = tickAudioRef.current;
+      if (ta) {
+        try {
+          ta.currentTime = 0;
+          void ta.play().catch(() => {
+          });
+        } catch {
+        }
+      }
+    };
+    if (physicsDriven) {
+      const from = mode === "reel" ? activeReelY : activeRotation;
+      const to = mode === "reel" ? finalReelY : finalRotation;
+      const crossUnit = mode === "reel" ? reelRowHeight : activeAnglePerWedge * 180 / Math.PI;
+      if (mode === "reel") visualReelYRef.current = from;
+      else visualRotationRef.current = from;
+      let crossings = 0;
+      const t0 = performance.now();
+      const step = (now) => {
+        const t = Math.min(1, (now - t0) / effectiveDuration);
+        const value = from + (to - from) * physicsRampDown(t);
+        if (mode === "reel") {
+          visualReelYRef.current = value;
+          const el = reelTapeRef.current;
+          if (el) {
+            el.style.transform = `translateY(${-(value + REEL_LEAD_IN * reelRowHeight)}px)`;
+          }
+        } else {
+          visualRotationRef.current = value;
+          const el = wheelSvgRef.current;
+          if (el) el.style.transform = `rotate(${value}deg)`;
+        }
+        const crossed = Math.floor(Math.abs(value - from) / crossUnit);
+        if (crossed > crossings) {
+          crossings = crossed;
+          fireTick();
+        }
+        if (t < 1) {
+          rafRef.current = requestAnimationFrame(step);
+        } else {
+          rafRef.current = null;
+          visualRotationRef.current = null;
+          visualReelYRef.current = null;
+        }
+      };
+      rafRef.current = requestAnimationFrame(step);
+    }
+    if (!physicsDriven && (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))
@@ -33912,16 +34031,7 @@ function RandomPlayerPicker({
         const eased = 1 - Math.pow(1 - progress, 3);
         const interval = startInterval + (endInterval - startInterval) * eased;
         tickInterval.current = setTimeout(() => {
-          onTick?.();
-          const ta = tickAudioRef.current;
-          if (ta) {
-            try {
-              ta.currentTime = 0;
-              void ta.play().catch(() => {
-              });
-            } catch {
-            }
-          }
+          fireTick();
           elapsed += interval;
           schedule();
         }, interval);
@@ -33929,7 +34039,7 @@ function RandomPlayerPicker({
       schedule();
     }
     winnerTimer.current = setTimeout(() => {
-      const picked = pool[finalWinnerIdx];
+      const picked = activePool[finalWinnerIdx];
       if (!picked) {
         setSpinning(false);
         return;
@@ -33975,9 +34085,13 @@ 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);
+          if (activePool.length - 1 >= 2) setWinner(null);
           setRotation(0);
           setReelY(0);
         }, 2800);
@@ -33986,8 +34100,6 @@ function RandomPlayerPicker({
   }, [
     pool,
     spinning,
-    n,
-    anglePerWedge,
     rotation,
     reelY,
     mode,
@@ -34002,6 +34114,7 @@ function RandomPlayerPicker({
     maxRevolutions,
     history,
     reducedMotion,
+    physicsDriven,
     enableHaptics,
     intensityCfg.particles,
     intensityCfg.durationMult,
@@ -34013,16 +34126,25 @@ function RandomPlayerPicker({
       if (spinRef && spinRef.current === spin) spinRef.current = null;
     };
   }, [spin, spinRef]);
+  const onPoolChangeRef = (0, import_react73.useRef)(onPoolChange);
+  (0, import_react73.useEffect)(() => {
+    onPoolChangeRef.current = onPoolChange;
+  });
+  (0, import_react73.useEffect)(() => {
+    onPoolChangeRef.current?.(pool);
+  }, [pool]);
   (0, import_react73.useEffect)(
     () => () => {
       if (winnerTimer.current) clearTimeout(winnerTimer.current);
       if (particleTimer.current) clearTimeout(particleTimer.current);
       if (popTimer.current) clearTimeout(popTimer.current);
       if (tickInterval.current) clearTimeout(tickInterval.current);
+      if (rafRef.current) cancelAnimationFrame(rafRef.current);
     },
     []
   );
   (0, import_react73.useEffect)(() => {
+    if (trigger === "external") return;
     const el = containerRef.current;
     if (!el) return;
     const h = (e) => {
@@ -34033,8 +34155,28 @@ function RandomPlayerPicker({
     };
     el.addEventListener("keydown", h);
     return () => el.removeEventListener("keydown", h);
-  }, [spin]);
+  }, [spin, trigger]);
   const reset = (0, import_react73.useCallback)(() => {
+    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;
+    }
+    if (rafRef.current) {
+      cancelAnimationFrame(rafRef.current);
+      rafRef.current = null;
+    }
+    visualRotationRef.current = null;
+    visualReelYRef.current = null;
+    pendingPopIdxRef.current = null;
+    setSpinning(false);
     setPool(participants);
     setHistory([]);
     setWinner(null);
@@ -34042,9 +34184,17 @@ function RandomPlayerPicker({
     setReelY(0);
     setParticles([]);
   }, [participants]);
+  (0, import_react73.useEffect)(() => {
+    if (resetRef) resetRef.current = reset;
+    return () => {
+      if (resetRef && resetRef.current === reset) resetRef.current = null;
+    };
+  }, [reset, resetRef]);
   const isIdle = n < 2;
+  const drainedByDraft = isIdle && participants.length >= 2;
+  const effectiveIdleCaption = drainedByDraft ? draftCompleteCaption : placeholderCaption;
   const placeholderDiscColor = dark ? "#2a3344" : "#e2e8f0";
-  if (isIdle && placeholderMode === "message") {
+  if (isIdle && !drainedByDraft && placeholderMode === "message") {
     return /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(
       "div",
       {
@@ -34066,6 +34216,8 @@ function RandomPlayerPicker({
   const shakeKeyframe = `rppShake_${intensity}`;
   const glowKeyframe = `rppGlow_${intensity}`;
   const pulseKeyframe = `rppPulse_${intensity}`;
+  const displayRotation = visualRotationRef.current ?? rotation;
+  const displayReelY = visualReelYRef.current ?? reelY;
   return /* @__PURE__ */ (0, import_jsx_runtime116.jsxs)(
     "div",
     {
@@ -34112,13 +34264,33 @@ function RandomPlayerPicker({
           [data-rpp-anim] { animation: none !important; }
         }
       ` }),
-        mode === "reel" ? /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(
+        isIdle && placeholderMode === "message" ? (
+          /* Drained draft in "message" mode — compact box in the wheel's
+             place; the winner card / stats / controls / history below stay
+             mounted so the endgame isn't a dead end. */
+          /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(
+            "div",
+            {
+              style: {
+                padding: "2rem 1rem",
+                textAlign: "center",
+                color: c.dim,
+                borderRadius: 12,
+                border: `1px dashed ${c.border}`
+              },
+              children: effectiveIdleCaption
+            }
+          )
+        ) : mode === "reel" ? /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(
           ReelStage,
           {
             pool,
             winner,
             spinning,
             reelY,
+            displayY: displayReelY,
+            cssTransition: !physicsDriven,
+            tapeRef: reelTapeRef,
             reelVisibleRows,
             reelRowHeight,
             size,
@@ -34127,7 +34299,7 @@ function RandomPlayerPicker({
             dark,
             isIdle,
             placeholderMode,
-            placeholderCaption,
+            placeholderCaption: effectiveIdleCaption,
             placeholderDiscColor,
             spinDuration,
             intensityCfg,
@@ -34184,6 +34356,7 @@ function RandomPlayerPicker({
                 /* @__PURE__ */ (0, import_jsx_runtime116.jsxs)(
                   "svg",
                   {
+                    ref: wheelSvgRef,
                     width: size,
                     height: size,
                     "aria-hidden": "true",
@@ -34192,8 +34365,8 @@ function RandomPlayerPicker({
                       top: 36,
                       left: 0,
                       transformOrigin: `${cx}px ${cy}px`,
-                      transform: `rotate(${rotation}deg)`,
-                      transition: spinning ? `transform ${reducedMotion ? 250 : Math.round(spinDuration * intensityCfg.durationMult)}ms ${intensityCfg.easing}` : "none",
+                      transform: `rotate(${displayRotation}deg)`,
+                      transition: spinning && !physicsDriven ? `transform ${reducedMotion ? 250 : Math.round(spinDuration * intensityCfg.durationMult)}ms ${intensityCfg.easing}` : "none",
                       filter: `drop-shadow(0 8px 28px ${dark ? "rgba(0,0,0,0.55)" : "rgba(0,0,0,0.15)"})`
                     },
                     children: [
@@ -34346,7 +34519,7 @@ function RandomPlayerPicker({
                       pointerEvents: "none",
                       zIndex: 3
                     },
-                    children: placeholderCaption
+                    children: effectiveIdleCaption
                   }
                 ),
                 particles.map((p) => /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(
@@ -38487,27 +38660,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]);
   (0, import_react76.useEffect)(() => {
@@ -38528,6 +38702,7 @@ function GameTimer({
   }, []);
   const reset = (0, import_react76.useCallback)(() => {
     setRunning(false);
+    elapsedRef.current = 0;
     setElapsedMs(0);
     setCompleted(false);
     setLaps([]);
@@ -39824,8 +39999,10 @@ function TeamGenerator({
   minPlayersPerTeam = 2,
   maxPlayers = Number.POSITIVE_INFINITY,
   defaultNames = [],
+  defaultTeams,
   onNamesChange,
   onGenerate,
+  onTeamsChange,
   onTeamCountChange,
   labels,
   ariaLabel = "Team generator",
@@ -39840,12 +40017,17 @@ function TeamGenerator({
   const [names, setNames] = (0, import_react78.useState)(defaultNames);
   const [input, setInput] = (0, import_react78.useState)("");
   const [teamCount, setTeamCount] = (0, import_react78.useState)(initialCount);
-  const [teams, setTeams] = (0, import_react78.useState)(null);
+  const [teams, setTeams] = (0, import_react78.useState)(
+    defaultTeams && defaultTeams.length > 0 ? defaultTeams : null
+  );
   const inputRef = (0, import_react78.useRef)(null);
   const minNames = teamCount * minPlayersPerTeam;
   (0, import_react78.useEffect)(() => {
     onNamesChange?.(names);
   }, [names, onNamesChange]);
+  (0, import_react78.useEffect)(() => {
+    onTeamsChange?.(teams);
+  }, [teams, onTeamsChange]);
   const addName = (0, import_react78.useCallback)(() => {
     const trimmed = input.trim();
     if (!trimmed) return;
@@ -40467,6 +40649,8 @@ function RoundRobinScheduler({
   theme: theme5 = "slate",
   darkMode,
   minTeams = 3,
+  maxTeams,
+  nameMaxLength,
   defaultTeams = [],
   resumeRounds,
   onTeamsChange,
@@ -40489,39 +40673,41 @@ function RoundRobinScheduler({
   (0, import_react79.useEffect)(() => {
     onTeamsChange?.(teams);
   }, [teams, onTeamsChange]);
-  const addTeams = (0, import_react79.useCallback)((raw) => {
-    const names = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-    if (names.length === 0) return;
-    setTeams((prev) => {
-      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 = (0, import_react79.useCallback)((incoming) => {
-    if (incoming.length === 0) return;
-    setTeams((prev) => {
+  const mergeNames = (0, import_react79.useCallback)(
+    (prev, incoming) => {
       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 = (0, import_react79.useCallback)(
+    (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 = (0, import_react79.useCallback)(
+    (incoming) => {
+      if (incoming.length === 0) return;
+      setTeams((prev) => mergeNames(prev, incoming));
+      setRounds([]);
+    },
+    [mergeNames]
+  );
   const handleKeyDown = (0, import_react79.useCallback)(
     (e) => {
       if (e.key === "Enter") {
@@ -41010,6 +41196,8 @@ function Scoreboard({
   onTeamsChange,
   onRoundAdvance,
   onNewGame,
+  onReset,
+  nameMaxLength,
   labels,
   ariaLabel = "Scoreboard",
   className
@@ -41084,7 +41272,8 @@ function Scoreboard({
     setRound(1);
     setHistory([]);
     setHistoryOpen(false);
-  }, []);
+    onReset?.();
+  }, [onReset]);
   const newGame = (0, import_react80.useCallback)(() => {
     setTeams(createDefaultTeams(seedCount, L.teamNamePrefix));
     setRound(1);
@@ -41306,6 +41495,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`