08연속 뽑기 — 당첨 칸을 빼고 도는 탈락 모드

<main class="stage">
<div class="el" id="el">
  <p class="el__hint">뽑힌 칸은 빠지고 남은 칸으로 각도를 재분배합니다 — 되돌리기도 있습니다</p>
  <div class="el__row">
    <div class="el__field" id="field" role="application" aria-label="탈락 모드 실험판" tabindex="0">
      <canvas class="el__cv" id="cv"></canvas>
    </div>
    <div class="el__side">
      <b class="el__num" id="left">6</b>
      <span class="el__unit">남은 항목 · 뽑히면 줄어든다</span>
      <div class="el__log" id="log"></div>
      <button class="el__btn" id="btn" type="button">직전 뽑기 되돌리기</button>
    </div>
  </div>
</div>
</main>

@use "../../../../site/static/demo-tokens" as *;

// 연속 뽑기 탈락 모드(08) — 움직임은 전부 캔버스 rAF 루프다. CSS @keyframes 를 두지 않는다.
// 페이퍼 무대. 칸 여섯 색은 파스텔 — 뽑힌 칸이 빠질 때 유령 프레임이 안 생기게
// 반투명이 아니라 채도만 낮춘 미리보기 색을 캔버스에서 계산해 쓴다.

$duration: $dur-loop;
$easing: $ease-out;
$color: $subject-blue;

@include stage($stage-paper);

.el {
  --w1: #b3bfd4;   // 파랑빛 파스텔 — 1번 칸
  --w2: #d8a3b4;   // 로즈 파스텔 — 2번 칸
  --w3: #a9c4b0;   // 세이지 파스텔 — 3번 칸
  --w4: #d9c48f;   // 골드 파스텔 — 4번 칸
  --w5: #c2a8d1;   // 플럼 파스텔 — 5번 칸
  --w6: #9fc6c2;   // 틸 파스텔 — 6번 칸
  --ink: #{$subject-ink};
  --cream: #{$subject-cream};

  display: flex; flex-direction: column; gap: $sp-2;
  width: 100%; max-width: 420px;
}

.el__hint {
  margin: 0; font-weight: 700; font-size: clamp(10px, 2.8vw, 12px); line-height: 1.35;
  color: $subject-ink;
}

.el__row { display: flex; gap: $sp-2; align-items: stretch; }

.el__field {
  position: relative; overflow: hidden;
  flex: 0 0 auto;
  width: clamp(176px, 46vw, 232px);
  height: clamp(176px, 46vw, 232px);
  border-radius: $r-card;
  background: rgba($subject-ink, .05);
  box-shadow: inset 0 0 0 1px rgba($subject-ink, .16);
  cursor: grab; touch-action: none;
}
.el__field:active { cursor: grabbing; }
.el__field:focus-visible { outline: 2px solid $color; outline-offset: 2px; }

.el__cv { display: block; width: 100%; height: 100%; }

.el__side {
  flex: 1; min-width: 0;
  display: flex; flex-direction: column; gap: $sp-1;
  padding-top: $sp-1;
}
.el__num {
  font-weight: 800; font-size: clamp(20px, 6vw, 30px); line-height: 1;
  color: $subject-blue-deep; font-variant-numeric: tabular-nums;
}
.el__unit { font-weight: 600; font-size: clamp(9px, 2.4vw, 11px); line-height: 1.4; color: rgba($subject-ink, .82); }

.el__log { display: flex; flex-direction: column; gap: $sp-1; margin-top: $sp-1; }
.el__chip {
  border-radius: $r-xs;
  padding: $sp-1 $sp-2;
  background: rgba($subject-ink, .08);
  color: $subject-ink;
  font-weight: 600; font-size: 10px; line-height: 1.4;
  width: fit-content;
}

.el__btn {
  border: 0; cursor: pointer;
  border-radius: $r-xs;
  padding: $sp-1 $sp-2;
  background: $subject-blue-deep; color: $subject-cream;
  font-weight: 700; font-size: 11px; line-height: 1.2;
  font-family: inherit;
  width: fit-content;
}
.el__btn:disabled { opacity: .45; cursor: default; }
.el__btn:focus-visible { outline: 2px solid $color; outline-offset: 2px; }

@media (max-width: 340px) {
  .el__hint { font-size: 8px; line-height: 1.3; }
  .el { gap: $sp-1; }
  .el__field { width: 150px; height: 150px; }
  .el__num { font-size: 16px; }
  .el__chip { padding: $sp-1; font-size: 9px; }
  .el__btn { padding: $sp-1; font-size: 9px; }
}

// reduce — 루프가 안 돈다. 두 명이 빠진 정지 한 장이 남는다.
@media (prefers-reduced-motion: reduce) {
  .el.is-still .el__field { cursor: default !important; }
  .el.is-still .el__btn { cursor: default; }
}

html, body {
  margin: 0;
  overflow: hidden;
}

.stage {
  box-sizing: border-box;
  min-height: 100vh;
  display: grid;
  place-items: center;
  margin: 0;
  background: #ffffff;
  font-family: -apple-system, "Segoe UI", "Noto Sans KR", sans-serif;
  padding: clamp(8px, 4vw, 24px);
}

.el {
  --w1: #b3bfd4;
  --w2: #d8a3b4;
  --w3: #a9c4b0;
  --w4: #d9c48f;
  --w5: #c2a8d1;
  --w6: #9fc6c2;
  --ink: #17141a;
  --cream: #fff7e6;
  display: flex;
  flex-direction: column;
  gap: 8px;
  width: 100%;
  max-width: 420px;
}

.el__hint {
  margin: 0;
  font-weight: 700;
  font-size: clamp(10px, 2.8vw, 12px);
  line-height: 1.35;
  color: #17141a;
}

.el__row {
  display: flex;
  gap: 8px;
  align-items: stretch;
}

.el__field {
  position: relative;
  overflow: hidden;
  flex: 0 0 auto;
  width: clamp(176px, 46vw, 232px);
  height: clamp(176px, 46vw, 232px);
  border-radius: 16px;
  background: rgba(23, 20, 26, 0.05);
  box-shadow: inset 0 0 0 1px rgba(23, 20, 26, 0.16);
  cursor: grab;
  touch-action: none;
}

.el__field:active {
  cursor: grabbing;
}

.el__field:focus-visible {
  outline: 2px solid #2f6df6;
  outline-offset: 2px;
}

.el__cv {
  display: block;
  width: 100%;
  height: 100%;
}

.el__side {
  flex: 1;
  min-width: 0;
  display: flex;
  flex-direction: column;
  gap: 4px;
  padding-top: 4px;
}

.el__num {
  font-weight: 800;
  font-size: clamp(20px, 6vw, 30px);
  line-height: 1;
  color: #0a4fe8;
  font-variant-numeric: tabular-nums;
}

.el__unit {
  font-weight: 600;
  font-size: clamp(9px, 2.4vw, 11px);
  line-height: 1.4;
  color: rgba(23, 20, 26, 0.82);
}

.el__log {
  display: flex;
  flex-direction: column;
  gap: 4px;
  margin-top: 4px;
}

.el__chip {
  border-radius: 4px;
  padding: 4px 8px;
  background: rgba(23, 20, 26, 0.08);
  color: #17141a;
  font-weight: 600;
  font-size: 10px;
  line-height: 1.4;
  width: fit-content;
}

.el__btn {
  border: 0;
  cursor: pointer;
  border-radius: 4px;
  padding: 4px 8px;
  background: #0a4fe8;
  color: #fff7e6;
  font-weight: 700;
  font-size: 11px;
  line-height: 1.2;
  font-family: inherit;
  width: fit-content;
}

.el__btn:disabled {
  opacity: 0.45;
  cursor: default;
}

.el__btn:focus-visible {
  outline: 2px solid #2f6df6;
  outline-offset: 2px;
}

@media (max-width: 340px) {
  .el__hint {
    font-size: 8px;
    line-height: 1.3;
  }
  .el {
    gap: 4px;
  }
  .el__field {
    width: 150px;
    height: 150px;
  }
  .el__num {
    font-size: 16px;
  }
  .el__chip {
    padding: 4px;
    font-size: 9px;
  }
  .el__btn {
    padding: 4px;
    font-size: 9px;
  }
}
@media (prefers-reduced-motion: reduce) {
  .el.is-still .el__field {
    cursor: default !important;
  }
  .el.is-still .el__btn {
    cursor: default;
  }
}

// 연속 뽑기 탈락 모드(08) — 뽑힌 항목을 목록에서 빼고 남은 항목으로 각도를 재분배하면
// 발표자 뽑기·빙고 뽑기가 된다. 당첨자는 사이드 기록 판에 옮겨 적히고 되돌리기로
// 직전 뽑기를 취소할 수 있다. 확정 전 미리보기 칸은 반투명이 아니라 채도만 낮춘다.
(function () {
  var root = document.getElementById('el');
  var field = document.getElementById('field');
  var cv = document.getElementById('cv');
  var leftEl = document.getElementById('left');
  var logEl = document.getElementById('log');
  var btnEl = document.getElementById('btn');
  if (!root || !field || !cv || !leftEl || !logEl || !btnEl) return;
  var ctx = cv.getContext('2d');
  var css = getComputedStyle(root);
  var PAL = [];
  for (var i = 1; i <= 6; i++) PAL.push(css.getPropertyValue('--w' + i).trim());
  var INK = css.getPropertyValue('--ink').trim();
  var CREAM = css.getPropertyValue('--cream').trim();
  var TAU = Math.PI * 2;
  var ALL = ['김하늘', '이준호', '박서연', '최도윤', '정민준', '한수아'];
  var alive = [0, 1, 2, 3, 4, 5];  // 살아있는 항목 인덱스 — PAL·ALL 둘 다 이 숫자로 본다
  var log = [];                  // 뽑힌 순서 — 되돌리기의 재료

  var ang = -0.5, vel = 0;
  var FRICTION = 0.28, STOP = 0.5;
  var settle = -1, pulse = -1, dpr = 1;
  var previewIdx = -1;           // 정지 직후 확정 전 하이라이트
  var flicks = [9, -11, 7.5, 12];
  var fi = 0, idle = 0, empty = 0;

  function fit() {
    var w = field.clientWidth, h = field.clientHeight;
    dpr = Math.min(2, window.devicePixelRatio || 1);
    cv.width = Math.round(w * dpr); cv.height = Math.round(h * dpr);
  }
  function norm(a) { a %= TAU; return a < 0 ? a + TAU : a; }
  function idxAt(a) {
    var n = alive.length;
    return n ? Math.floor(norm(-Math.PI / 2 - a) / (TAU / n)) % n : -1;
  }
  // hex 채도를 낮춘 미리보기 색 — 반투명이 아니라 채도 조절이라 유령이 안 생긴다
  function desat(hex) {
    var r = parseInt(hex.slice(1, 3), 16), g = parseInt(hex.slice(3, 5), 16), b = parseInt(hex.slice(5, 7), 16);
    var avg = (r + g + b) / 3;
    r = Math.round(r * 0.45 + avg * 0.55);
    g = Math.round(g * 0.45 + avg * 0.55);
    b = Math.round(b * 0.45 + avg * 0.55);
    return 'rgb(' + r + ',' + g + ',' + b + ')';
  }

  function draw() {
    var w = cv.width / dpr, h = cv.height / dpr;
    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
    ctx.clearRect(0, 0, w, h);
    var n = alive.length, seg = TAU / n;
    var cx = w / 2, cy = h / 2, R = Math.min(w, h) / 2 - 10;
    if (!n) {
      ctx.fillStyle = INK;
      ctx.font = '700 13px sans-serif';
      ctx.textAlign = 'center'; ctx.textBaseline = 'middle';
      ctx.fillText('전원 완료', cx, cy);
      return;
    }
    ctx.save(); ctx.translate(cx, cy); ctx.rotate(ang);
    for (var k = 0; k < n; k++) {
      var a0 = k * seg;
      var base = PAL[alive[k] % PAL.length];
      ctx.beginPath(); ctx.moveTo(0, 0);
      ctx.arc(0, 0, R, a0, a0 + seg); ctx.closePath();
      ctx.fillStyle = (settle >= 0 && k === previewIdx) ? desat(base) : base;
      ctx.fill();
      ctx.strokeStyle = 'rgba(23,20,26,.20)'; ctx.lineWidth = 1; ctx.stroke();
      var mid = a0 + seg / 2;
      ctx.save(); ctx.rotate(mid);
      ctx.fillStyle = INK;
      ctx.font = '700 11px sans-serif';
      ctx.textAlign = 'right'; ctx.textBaseline = 'middle';
      ctx.fillText(ALL[alive[k]], R - 12, 0);
      ctx.restore();
    }
    ctx.beginPath(); ctx.arc(0, 0, 12, 0, TAU);
    ctx.fillStyle = CREAM; ctx.fill(); ctx.strokeStyle = 'rgba(23,20,26,.35)'; ctx.stroke();
    if (pulse >= 0) {
      ctx.beginPath(); ctx.arc(0, 0, 12 + pulse * 20, 0, TAU);
      ctx.strokeStyle = 'rgba(23,20,26,' + (1 - pulse) * 0.5 + ')';
      ctx.lineWidth = 2; ctx.stroke();
    }
    // 확정 마커 — 뽑혀서 빠진 인원수만큼 허브 아래 사각 칩(fillRect)으로 쌓는다
    var done = ALL.length - alive.length;
    for (var d2 = 0; d2 < done; d2++) {
      ctx.fillStyle = PAL[d2 % PAL.length];
      ctx.fillRect(-9 + d2 * 4.4, 18, 3.4, 3.4);
    }
    ctx.restore();
    ctx.beginPath();
    ctx.moveTo(cx - 6, cy - R - 8); ctx.lineTo(cx + 6, cy - R - 8); ctx.lineTo(cx, cy - R + 7);
    ctx.closePath(); ctx.fillStyle = INK; ctx.fill();
  }

  function renderLog() {
    logEl.textContent = '';
    for (var q = log.length - 1; q >= 0; q--) {
      var row = document.createElement('span');
      row.className = 'el__chip';
      row.textContent = (q + 1) + '번 ' + ALL[log[q]];
      logEl.appendChild(row);
    }
    leftEl.textContent = String(alive.length);
    btnEl.disabled = !log.length;
  }

  // 확정 — 뽑힌 항목을 빼고 각도를 재분배한다
  function commit() {
    if (previewIdx < 0 || !alive.length) return;
    var winner = alive.splice(previewIdx, 1)[0];
    log.push(winner);
    previewIdx = -1; settle = -1; pulse = -1;
    renderLog();
  }

  btnEl.addEventListener('click', function () {
    if (!log.length) return;
    var back = log.pop();
    alive.push(back);
    previewIdx = -1; settle = -1; pulse = -1;
    renderLog();
    idle = 0.8;
  });

  var drag = { on: false, lastA: 0, lastT: 0, v: 0 };
  function angleAt(e) {
    var b = field.getBoundingClientRect();
    return Math.atan2(e.clientY - (b.top + b.height / 2), e.clientX - (b.left + b.width / 2));
  }
  field.addEventListener('pointerdown', function (e) {
    drag.on = true; drag.lastA = angleAt(e); drag.lastT = performance.now(); drag.v = 0;
    if (field.setPointerCapture) { try { field.setPointerCapture(e.pointerId); } catch (err) { /* 캡처 실패는 회전에 영향 없다 */ } }
  });
  field.addEventListener('pointermove', function (e) {
    if (!drag.on) return;
    var a = angleAt(e), now = performance.now();
    var dA = a - drag.lastA;
    if (dA > Math.PI) dA -= TAU;
    if (dA < -Math.PI) dA += TAU;
    ang += dA;
    var dt = Math.max(1, now - drag.lastT) / 1000;
    drag.v = 0.65 * drag.v + 0.35 * (dA / dt);
    drag.lastA = a; drag.lastT = now;
    idle = 0;
  });
  function endDrag() {
    if (!drag.on) return;
    drag.on = false;
    vel = Math.max(-20, Math.min(20, drag.v));
    if (Math.abs(vel) < 1.5) vel = flicks[0];
    settle = -1; pulse = -1;
  }
  field.addEventListener('pointerup', endDrag);
  field.addEventListener('pointercancel', endDrag);
  field.addEventListener('keydown', function (e) {
    if (e.key === ' ' || e.key === 'Enter') {
      e.preventDefault();
      if (alive.length) { vel = flicks[fi++ % flicks.length]; settle = -1; pulse = -1; }
    }
  });

  var reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
  var last = performance.now();
  function step(now) {
    var dt = Math.min(64, now - last) / 1000; last = now;
    if (!drag.on) {
      if (vel !== 0) {
        ang += vel * dt;
        vel *= Math.pow(FRICTION, dt);
        if (Math.abs(vel) < STOP) { vel = 0; settle = 0; pulse = 0; previewIdx = idxAt(ang); }
      } else if (idle > 0) { idle -= dt; }
      else if (settle >= 0) {
        settle += dt; pulse = Math.min(1, settle / 0.3);
        if (settle > 0.62) {
          commit();                       // 확정 — 칸이 빠지고 재분배
          if (alive.length) { vel = flicks[fi++ % flicks.length]; settle = -1; pulse = -1; }
        }
      } else if (alive.length) {
        vel = flicks[fi++ % flicks.length];
      } else {
        // 전원 완료 — 잠깐 보여 주고 처음부터 다시 시작한다
        empty += dt;
        if (empty > 0.7) {
          alive = [0, 1, 2, 3, 4, 5]; log = []; previewIdx = -1; empty = 0;
          renderLog();
          vel = flicks[fi++ % flicks.length];
        }
      }
    }
    draw();
    requestAnimationFrame(step);
  }

  fit();
  renderLog();
  window.addEventListener('resize', fit);
  if (reduce) {
    // 정지 한 장 — 두 명이 빠진 상태로 고정하고 루프는 돌지 않는다
    alive = [0, 1, 3, 5];
    log = [4, 2];
    ang = -0.5 + 2.2;
    renderLog();
    draw();
    root.classList.add('is-still');
  } else {
    vel = flicks[fi++ % flicks.length];
    requestAnimationFrame(step);
  }
})();

// SpinWheelEliminationMode — vanilla 판(run/332/demo/08-spin-wheel-elimination-mode/index.html) 의 React 포트.
// alive 인덱스 배열이 살아있는 항목이고, 뽑히면 splice 로 빼고 남은 칸 수로 각도를 재분배한다.
// 되돌리기는 log 배열에서 pop 해 alive 에 되돌린다. 확정 전 미리보기 칸은 반투명이 아니라
// desat() 로 채도만 낮춘 색을 쓴다 — 유령 프레임이 안 생긴다.
// 움직임은 전부 캔버스 rAF 루프가 그리므로 CSS 애니메이션이 없다.
import { useEffect, useRef, useState } from "react";
import type { CSSProperties, PointerEvent } from "react";
import styles from "./SpinWheelEliminationMode.module.scss";

// demo.py 의 ambient react 스텁은 KeyboardEvent 를 export 하지 않는다 — 최소 자체 타입으로 대체
type KeyEvt = { key: string; preventDefault(): void };

export type SpinWheelEliminationModeProps = {
  duration?: string;
  easing?: string;
  color?: string;
};

type Vars = CSSProperties & { "--duration"?: string; "--easing"?: string; "--color"?: string };
type Box<T> = { current: T };

const TAU = Math.PI * 2;
const ALL = ["김하늘", "이준호", "박서연", "최도윤", "정민준", "한수아"];
const FRICTION = 0.28, STOP = 0.5;
const FLICKS = [9, -11, 7.5, 12];
const PAL = ["#b3bfd4", "#d8a3b4", "#a9c4b0", "#d9c48f", "#c2a8d1", "#9fc6c2"];
const INK = "#17141a";
const CREAM = "#fff7e6";
const HINT = "뽑힌 칸은 빠지고 남은 칸으로 각도를 재분배합니다 — 되돌리기도 있습니다";
const ARIA_FIELD = "탈락 모드 실험판";
const UNIT = "남은 항목 · 뽑히면 줄어든다";
const UNDO_LABEL = "직전 뽑기 되돌리기";
const ALL_DONE = "전원 완료";

// hex 채도를 낮춘 미리보기 색 — 반투명이 아니라 채도 조절이라 유령이 안 생긴다
function desat(hex: string): string {
  let r = parseInt(hex.slice(1, 3), 16), g = parseInt(hex.slice(3, 5), 16), b = parseInt(hex.slice(5, 7), 16);
  const avg = (r + g + b) / 3;
  r = Math.round(r * 0.45 + avg * 0.55);
  g = Math.round(g * 0.45 + avg * 0.55);
  b = Math.round(b * 0.45 + avg * 0.55);
  return "rgb(" + r + "," + g + "," + b + ")";
}

export default function SpinWheelEliminationMode({
  duration = "2s",
  easing = "ease-out",
  color = "#2f6df6"
}: SpinWheelEliminationModeProps) {
  const fieldRef = useRef<HTMLDivElement | null>(null);
  const cvRef = useRef<HTMLCanvasElement | null>(null);
  const leftRef = useRef<HTMLSpanElement | null>(null);
  const ctxRef = useRef<CanvasRenderingContext2D | null>(null);
  const stRef = useRef({
    ang: -0.5, vel: 0, settle: -1, pulse: -1, previewIdx: -1, dpr: 1, fi: 0, idle: 0, empty: 0,
    alive: [0, 1, 2, 3, 4, 5], log: [] as number[],
    drag: { on: false, lastA: 0, lastT: 0, v: 0 }
  }) as Box<{
    ang: number; vel: number; settle: number; pulse: number; previewIdx: number; dpr: number; fi: number; idle: number; empty: number;
    alive: number[]; log: number[];
    drag: { on: boolean; lastA: number; lastT: number; v: number };
  }>;
  const [logChips, setLogChips] = useState<number[]>([]);
  const [aliveCount, setAliveCount] = useState(6);
  const lastRef = useRef(0) as Box<number>;
  const rafRef = useRef(0) as Box<number>;
  const [still, setStill] = useState(false);

  function reduced(): boolean {
    return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
  }

  function fit(): void {
    const st = stRef.current;
    const field = fieldRef.current, cv = cvRef.current;
    if (!field || !cv) return;
    const ctx = cv.getContext("2d");
    if (!ctx) return;
    st.dpr = Math.min(2, window.devicePixelRatio || 1);
    cv.width = Math.round(field.clientWidth * st.dpr);
    cv.height = Math.round(field.clientHeight * st.dpr);
    ctxRef.current = ctx;
  }

  function norm(a: number): number {
    const r = a % TAU;
    return r < 0 ? r + TAU : r;
  }
  function idxAt(a: number): number {
    const n = stRef.current.alive.length;
    return n ? Math.floor(norm(-Math.PI / 2 - a) / (TAU / n)) % n : -1;
  }

  function draw(): void {
    const st = stRef.current;
    const ctx = ctxRef.current;
    if (!ctx) return;
    const w = cvRef.current!.width / st.dpr, h = cvRef.current!.height / st.dpr;
    ctx.setTransform(st.dpr, 0, 0, st.dpr, 0, 0);
    ctx.clearRect(0, 0, w, h);
    const n = st.alive.length, seg = TAU / n;
    const cx = w / 2, cy = h / 2, R = Math.min(w, h) / 2 - 10;
    if (!n) {
      ctx.fillStyle = INK;
      ctx.font = "700 13px sans-serif";
      ctx.textAlign = "center"; ctx.textBaseline = "middle";
      ctx.fillText(ALL_DONE, cx, cy);
      return;
    }
    ctx.save(); ctx.translate(cx, cy); ctx.rotate(st.ang);
    for (let k = 0; k < n; k++) {
      const a0 = k * seg;
      const base = PAL[st.alive[k] % PAL.length];
      ctx.beginPath(); ctx.moveTo(0, 0);
      ctx.arc(0, 0, R, a0, a0 + seg); ctx.closePath();
      ctx.fillStyle = (st.settle >= 0 && k === st.previewIdx) ? desat(base) : base;
      ctx.fill();
      ctx.strokeStyle = "rgba(23,20,26,.20)"; ctx.lineWidth = 1; ctx.stroke();
      const mid = a0 + seg / 2;
      ctx.save(); ctx.rotate(mid);
      ctx.fillStyle = INK;
      ctx.font = "700 11px sans-serif";
      ctx.textAlign = "right"; ctx.textBaseline = "middle";
      ctx.fillText(ALL[st.alive[k]], R - 12, 0);
      ctx.restore();
    }
    ctx.beginPath(); ctx.arc(0, 0, 12, 0, TAU);
    ctx.fillStyle = CREAM; ctx.fill(); ctx.strokeStyle = "rgba(23,20,26,.35)"; ctx.stroke();
    if (st.pulse >= 0) {
      ctx.beginPath(); ctx.arc(0, 0, 12 + st.pulse * 20, 0, TAU);
      ctx.strokeStyle = "rgba(23,20,26," + (1 - st.pulse) * 0.5 + ")";
      ctx.lineWidth = 2; ctx.stroke();
    }
    // 확정 마커 — 뽑혀서 빠진 인원수만큼 허브 아래 사각 칩(fillRect)으로 쌓는다
    const done = ALL.length - st.alive.length;
    for (let d2 = 0; d2 < done; d2++) {
      ctx.fillStyle = PAL[d2 % PAL.length];
      ctx.fillRect(-9 + d2 * 4.4, 18, 3.4, 3.4);
    }
    ctx.restore();
    ctx.beginPath();
    ctx.moveTo(cx - 6, cy - R - 8); ctx.lineTo(cx + 6, cy - R - 8); ctx.lineTo(cx, cy - R + 7);
    ctx.closePath(); ctx.fillStyle = INK; ctx.fill();
  }

  function syncSide(): void {
    const st = stRef.current;
    setLogChips(st.log.slice());
    setAliveCount(st.alive.length);
    const lf = leftRef.current;
    if (lf) lf.textContent = String(st.alive.length);
  }

  // 확정 — 뽑힌 항목을 빼고 각도를 재분배한다
  function commit(): void {
    const st = stRef.current;
    if (st.previewIdx < 0 || !st.alive.length) return;
    const winner = st.alive.splice(st.previewIdx, 1)[0];
    st.log.push(winner);
    st.previewIdx = -1; st.settle = -1; st.pulse = -1;
    syncSide();
  }
  function undo(): void {
    const st = stRef.current;
    if (!st.log.length) return;
    const back = st.log.pop()!;
    st.alive.push(back);
    st.previewIdx = -1; st.settle = -1; st.pulse = -1;
    syncSide();
    st.idle = 0.8;
  }

  function angleAt(e: PointerEvent<HTMLDivElement>): number {
    const b = e.currentTarget.getBoundingClientRect();
    return Math.atan2(e.clientY - (b.top + b.height / 2), e.clientX - (b.left + b.width / 2));
  }
  function onPointerDown(e: PointerEvent<HTMLDivElement>): void {
    const st = stRef.current;
    st.drag.on = true; st.drag.lastA = angleAt(e); st.drag.lastT = performance.now(); st.drag.v = 0;
    try { e.currentTarget.setPointerCapture(e.pointerId); } catch { /* 캡처 실패는 회전에 영향 없다 */ }
  }
  function onPointerMove(e: PointerEvent<HTMLDivElement>): void {
    const st = stRef.current;
    if (!st.drag.on) return;
    const a = angleAt(e), now = performance.now();
    let dA = a - st.drag.lastA;
    if (dA > Math.PI) dA -= TAU;
    if (dA < -Math.PI) dA += TAU;
    st.ang += dA;
    const dt = Math.max(1, now - st.drag.lastT) / 1000;
    st.drag.v = 0.65 * st.drag.v + 0.35 * (dA / dt);
    st.drag.lastA = a; st.drag.lastT = now;
    st.idle = 0;
  }
  function endDrag(): void {
    const st = stRef.current;
    if (!st.drag.on) return;
    st.drag.on = false;
    st.vel = Math.max(-20, Math.min(20, st.drag.v));
    if (Math.abs(st.vel) < 1.5) st.vel = FLICKS[0];
    st.settle = -1; st.pulse = -1;
  }
  function onKeyDown(e: KeyEvt): void {
    const st = stRef.current;
    if (e.key === " " || e.key === "Enter") {
      e.preventDefault();
      if (st.alive.length) { st.vel = FLICKS[st.fi++ % FLICKS.length]; st.settle = -1; st.pulse = -1; }
    }
  }

  function step(now: number): void {
    const st = stRef.current;
    const dt = Math.min(64, now - lastRef.current) / 1000; lastRef.current = now;
    if (!st.drag.on) {
      if (st.vel !== 0) {
        st.ang += st.vel * dt;
        st.vel *= Math.pow(FRICTION, dt);
        if (Math.abs(st.vel) < STOP) { st.vel = 0; st.settle = 0; st.pulse = 0; st.previewIdx = idxAt(st.ang); }
      } else if (st.idle > 0) { st.idle -= dt; }
      else if (st.settle >= 0) {
        st.settle += dt; st.pulse = Math.min(1, st.settle / 0.3);
        if (st.settle > 0.62) {
          commit();                       // 확정 — 칸이 빠지고 재분배
          if (st.alive.length) { st.vel = FLICKS[st.fi++ % FLICKS.length]; st.settle = -1; st.pulse = -1; }
        }
      } else if (st.alive.length) {
        st.vel = FLICKS[st.fi++ % FLICKS.length];
      } else {
        // 전원 완료 — 잠깐 보여 주고 처음부터 다시 시작한다
        st.empty += dt;
        if (st.empty > 0.7) {
          st.alive = [0, 1, 2, 3, 4, 5]; st.log = []; st.previewIdx = -1; st.empty = 0;
          syncSide();
          st.vel = FLICKS[st.fi++ % FLICKS.length];
        }
      }
    }
    draw();
    rafRef.current = requestAnimationFrame(step);
  }

  useEffect(() => {
    fit();
    function onResize(): void { fit(); }
    window.addEventListener("resize", onResize);
    if (reduced()) {
      // 정지 한 장 — 두 명이 빠진 상태로 고정하고 루프는 돌지 않는다
      const st = stRef.current;
      st.alive = [0, 1, 3, 5];
      st.log = [4, 2];
      st.ang = -0.5 + 2.2;
      syncSide();
      draw();
      setStill(true);
    } else {
      stRef.current.vel = FLICKS[stRef.current.fi++ % FLICKS.length];
      lastRef.current = performance.now();
      rafRef.current = requestAnimationFrame(step);
    }
    return () => {
      window.removeEventListener("resize", onResize);
      cancelAnimationFrame(rafRef.current);
    };
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);

  const rootCls = still ? styles.el + " " + styles.isStill : styles.el;
  return (
    <main className={styles.stage}>
      <div className={rootCls} style={{ "--duration": duration, "--easing": easing, "--color": color } as Vars}>
        <p className={styles.hint}>{HINT}</p>
        <div className={styles.row}>
          <div
            className={styles.field}
            ref={fieldRef}
            role="application"
            aria-label={ARIA_FIELD}
            tabIndex={0}
            onKeyDown={onKeyDown}
            onPointerDown={onPointerDown}
            onPointerMove={onPointerMove}
            onPointerUp={endDrag}
            onPointerCancel={endDrag}
          >
            <canvas className={styles.cv} ref={cvRef}></canvas>
          </div>
          <div className={styles.side}>
            <b className={styles.num} ref={leftRef}>{aliveCount}</b>
            <span className={styles.unit}>{UNIT}</span>
            <div className={styles.log}>
              {/* vanilla 와 같이 최근 뽑기부터 거꾸로 나열한다 — 번호는 뽑힌 순서 그대로 */}
              {logChips.map((_, i) => {
                const q = logChips.length - 1 - i;
                return <span key={q} className={styles.chip}>{q + 1}번 {ALL[logChips[q]]}</span>;
              })}
            </div>
            <button type="button" className={styles.btn} disabled={!logChips.length} onClick={undo}>
              {UNDO_LABEL}
            </button>
          </div>
        </div>
      </div>
    </main>
  );
}