@ihabdevteam/core 0.322.0 → 0.324.0

package/dist/packages/core/src/components/Training/trainingMissStats.js

@@ -17,7 +17,7 @@
  */
 import { compareKorean } from '../../utils/textSort';
 /** 같은 시각 두 행의 차례 — 둘 다 id 가 있을 때만 가린다(숫자는 수 크기, 그 밖은 글자 사전순). 못 가리면 0. */
-function 같은시각차례(a, b) {
+function sameTimeOrder(a, b) {
     if (a == null || b == null || a === '' || b === '')
         return 0;
     if (typeof a === 'number' && typeof b === 'number')
@@ -39,16 +39,16 @@ function 같은시각차례(a, b) {
  * (최신 먼저 넘기면 같은 시각 행의 최근이 뒤집힌다. 시각이 다른 행은 차례와 상관없이 맞다.)
  */
 export function summarizeMisses(records) {
-    const 모음 = new Map();
+    const byKey = new Map();
     let counted = 0;
     let skippedNoTitle = 0;
     /* 최근 것을 알려면 시간순으로 훑어야 한다. 서버는 최신순으로 주지만 여기서 다시
        정렬한다 — 부르는 쪽의 차례에 기대면 그쪽이 바뀔 때 조용히 어긋난다. */
-    const 시간순 = records
-        .map((r, 자리) => ({ r, 자리 }))
-        .sort((a, b) => a.r.answeredAt.localeCompare(b.r.answeredAt) || 같은시각차례(a.r.id, b.r.id) || a.자리 - b.자리)
+    const byTime = records
+        .map((r, at) => ({ r, at }))
+        .sort((a, b) => a.r.answeredAt.localeCompare(b.r.answeredAt) || sameTimeOrder(a.r.id, b.r.id) || a.at - b.at)
         .map(x => x.r);
-    for (const r of 시간순) {
+    for (const r of byTime) {
         // 요약·시간 행은 문항이 아니다. 틀림으로 세면 한 판마다 오답이 늘어난다.
         if (r.isCorrect == null)
             continue;
@@ -60,7 +60,7 @@ export function summarizeMisses(records) {
         counted++;
         const id = r.itemId?.trim() || title;
         const key = `${r.trainingType}|${id}`;
-        const cur = 모음.get(key) ?? {
+        const cur = byKey.get(key) ?? {
             trainingType: r.trainingType, itemId: id, title,
             tried: 0, wrong: 0,
             latestCorrect: r.isCorrect, latestAt: r.answeredAt, lastSelected: r.selected,
@@ -84,9 +84,9 @@ export function summarizeMisses(records) {
             if (at !== 0)
                 cur.setIds.unshift(r.setId);
         }
-        모음.set(key, cur);
+        byKey.set(key, cur);
     }
-    const items = [...모음.entries()].map(([key, v]) => ({
+    const items = [...byKey.entries()].map(([key, v]) => ({
         key,
         trainingType: v.trainingType,
         itemId: v.itemId,
@@ -126,13 +126,13 @@ export function nextMisses(items, limit = 8) {
  * 못 잡은 것이 많은 유형이 먼저. 같으면 유형 키로 갈라 차례를 못 박는다.
  */
 export function missesByType(items) {
-    const 모음 = new Map();
+    const byKey = new Map();
     for (const i of items) {
-        const arr = 모음.get(i.trainingType) ?? [];
+        const arr = byKey.get(i.trainingType) ?? [];
         arr.push(i);
-        모음.set(i.trainingType, arr);
+        byKey.set(i.trainingType, arr);
     }
-    const out = [...모음.entries()].map(([trainingType, list]) => ({
+    const out = [...byKey.entries()].map(([trainingType, list]) => ({
         trainingType,
         items: list,
         pending: list.filter(i => !i.latestCorrect).length,
@@ -162,7 +162,7 @@ export const SENTENCE_TRAINING_TYPES = ['LISTEN_IN_NOISE', 'SHORT_STORY', 'LONG_
  * 밀렸다"고 해 놓고 두 개짜리 세트가 나온다 — 몇 개를 못 담았는지 함께 돌려준다.
  */
 export function reviewSetPlan(items) {
-    const 모음 = new Map();
+    const byKey = new Map();
     let noSet = 0;
     for (const i of items) {
         if (i.latestCorrect)
@@ -173,17 +173,17 @@ export function reviewSetPlan(items) {
             continue;
         }
         const key = `${i.trainingType}|${setId}`;
-        const cur = 모음.get(key) ?? { setId, trainingType: i.trainingType, pending: 0 };
+        const cur = byKey.get(key) ?? { setId, trainingType: i.trainingType, pending: 0 };
         cur.pending++;
-        모음.set(key, cur);
+        byKey.set(key, cur);
     }
     /* 못 잡은 것이 많은 세트가 먼저. 같으면 유형·uuid 로 갈라 차례를 못 박는다 —
        같은 자료에 두 번 물어 순서가 다르면 사람은 값이 바뀐 줄 안다. */
-    const 정렬 = (a, b) => b.pending - a.pending || a.trainingType.localeCompare(b.trainingType) || a.setId.localeCompare(b.setId);
-    const all = [...모음.values()];
+    const byOrder = (a, b) => b.pending - a.pending || a.trainingType.localeCompare(b.trainingType) || a.setId.localeCompare(b.setId);
+    const all = [...byKey.values()];
     return {
-        sentence: all.filter(r => SENTENCE_TRAINING_TYPES.includes(r.trainingType)).sort(정렬),
-        word: all.filter(r => !SENTENCE_TRAINING_TYPES.includes(r.trainingType)).sort(정렬),
+        sentence: all.filter(r => SENTENCE_TRAINING_TYPES.includes(r.trainingType)).sort(byOrder),
+        word: all.filter(r => !SENTENCE_TRAINING_TYPES.includes(r.trainingType)).sort(byOrder),
         noSet,
     };
 }

package/dist/packages/core/src/components/Training/trainingPopupUtils.js

@@ -44,11 +44,11 @@ export function splitTrainingVariants(value) {
     }
     return [String(value)];
 }
-const 이름 = (key, 기본) => {
-    if (!기본)
-        return 기본;
-    const s = typeof i18n?.t === "function" ? i18n.t(key, { defaultValue: 기본 }) : undefined;
-    return typeof s === "string" && s ? s : 기본;
+const labelOf = (key, fallback) => {
+    if (!fallback)
+        return fallback;
+    const s = typeof i18n?.t === "function" ? i18n.t(key, { defaultValue: fallback }) : undefined;
+    return typeof s === "string" && s ? s : fallback;
 };
 /** @public */
 export function resolveTrainingPopupMeta(trainingData, depth, fallbackTitle) {
@@ -71,8 +71,8 @@ export function resolveTrainingPopupMeta(trainingData, depth, fallbackTitle) {
             : undefined,
         // 카테고리 이름은 지금 언어로(topic.* · topic.sub.*, 사전에 없으면 등록된 이름)
         iconTooltip: [
-            category ? 이름(`topic.${category.key}`, category.label) : undefined,
-            subCategory ? 이름(`topic.sub.${subCategory.key}`, subCategory.label) : undefined,
+            category ? labelOf(`topic.${category.key}`, category.label) : undefined,
+            subCategory ? labelOf(`topic.sub.${subCategory.key}`, subCategory.label) : undefined,
         ].filter(Boolean).join(" / ") || undefined,
     };
 }

package/dist/packages/core/src/components/Training/useAudioPreview.js

@@ -55,7 +55,7 @@ export function useAudioPreview(trainingData, typeKey) {
     const playingRef = useRef(false);
     /* 지금 미리 듣기를 멈추는 함수 — 스피커 자물쇠(currentSound.ts)에 건다. 다른 블록 미리 듣기·훈련 소리가 울리면 이것이 불린다.
        전에는 자물쇠에 참여하지 않아 바구니의 블록 둘을 잇달아 누르면 두 문장이 함께 울렸다. */
-    const 멈춤Ref = useRef(null);
+    const stopRef = useRef(null);
     const previewBtnRef = useRef(null);
     const [previewHover, setPreviewHover] = useState(false);
     // downloadSound()로 만든 blob URL만 추적 — getSignedOrPublicUrl()이 반환하는 http(s) URL은
@@ -134,8 +134,8 @@ export function useAudioPreview(trainingData, typeKey) {
         e.stopPropagation();
         e.preventDefault();
         if (playingRef.current) {
-            if (멈춤Ref.current)
-                stopSoundIfOwner(멈춤Ref.current);
+            if (stopRef.current)
+                stopSoundIfOwner(stopRef.current);
             playingRef.current = false;
             try {
                 previewAudioRef.current?.pause();
@@ -150,13 +150,13 @@ export function useAudioPreview(trainingData, typeKey) {
             return;
         /* pause() 만으로는 ended 가 오지 않아 기다리던 약속이 풀리지 않는다 — 멈출 때 풀어
            반복을 끝낸다. 그 일을 `playOneShot().stop()` 이 맡는다((85) 3단계로 한 자리에 모았다). */
-        let 지금소리 = null;
-        const 멈춤 = () => {
+        let currentSound = null;
+        const stop = () => {
             playingRef.current = false;
-            지금소리?.stop();
+            currentSound?.stop();
         };
-        멈춤Ref.current = 멈춤;
-        const release = claimSound(멈춤);
+        stopRef.current = stop;
+        const release = claimSound(stop);
         playingRef.current = true;
         setPlaying(true);
         for (let i = 0; i < previewUrls.length; i++) {
@@ -166,16 +166,16 @@ export function useAudioPreview(trainingData, typeKey) {
             if (!url)
                 continue;
             setPlayingIndex(i);
-            지금소리 = playOneShot(url);
-            previewAudioRef.current = 지금소리.el;
+            currentSound = playOneShot(url);
+            previewAudioRef.current = currentSound.el;
             /* 끝까지 들었으면 다음 소리로. 못 틀었거나(error·거절) 멈췄으면 거기서 끝낸다 —
                전에는 끝까지 들음은 `resolve`, 못 틀음은 `reject`, 멈춤은 또 `resolve` 라 길이 셋이었다. */
-            if (!(await 지금소리.done))
+            if (!(await currentSound.done))
                 break;
         }
         release();
-        if (멈춤Ref.current === 멈춤) {
-            멈춤Ref.current = null;
+        if (stopRef.current === stop) {
+            stopRef.current = null;
             playingRef.current = false;
             setPlaying(false);
             setPlayingIndex(-1);
@@ -184,8 +184,8 @@ export function useAudioPreview(trainingData, typeKey) {
     // Pause and release audio on unmount
     useEffect(() => {
         return () => {
-            if (멈춤Ref.current)
-                stopSoundIfOwner(멈춤Ref.current);
+            if (stopRef.current)
+                stopSoundIfOwner(stopRef.current);
             playingRef.current = false;
             try {
                 previewAudioRef.current?.pause();

package/dist/packages/core/src/components/Training/useFloatingFocus.js

@@ -21,35 +21,35 @@ export function useFloatingFocus(open, findRoot, returnTo) {
         if (!open || typeof document === 'undefined')
             return;
         let raf = null;
-        let 남은틀 = 10; // Tooltip 은 위치를 잰 뒤에야 보인다 — 보이기 전 focus() 는 먹지 않아 몇 틀 다시 해 본다
-        const 넣기 = () => {
+        let framesLeft = 10; // Tooltip 은 위치를 잰 뒤에야 보인다 — 보이기 전 focus() 는 먹지 않아 몇 틀 다시 해 본다
+        const tryFocus = () => {
             raf = null;
             const root = findRootRef.current();
-            const 첫칸 = root
+            const firstTarget = root
                 ? Array.from(root.querySelectorAll(FOCUSABLE_SELECTOR)).find((el) => !el.closest('[aria-hidden="true"]'))
                 : undefined;
-            if (첫칸) {
+            if (firstTarget) {
                 try {
-                    첫칸.focus();
+                    firstTarget.focus();
                 }
                 catch (e) { /* 떼어진 노드 */ }
-                if (document.activeElement === 첫칸)
+                if (document.activeElement === firstTarget)
                     return;
             }
-            if (--남은틀 > 0)
-                raf = requestAnimationFrame(넣기);
+            if (--framesLeft > 0)
+                raf = requestAnimationFrame(tryFocus);
         };
-        raf = requestAnimationFrame(넣기);
+        raf = requestAnimationFrame(tryFocus);
         return () => {
             if (raf !== null)
                 cancelAnimationFrame(raf);
             // 닫혔다(또는 떠난다) — 초점이 창과 함께 사라져 body 로 떨어졌을 때만 연 단추로 돌려준다
-            const 지금 = document.activeElement;
-            if (!지금 || 지금 === document.body || !document.contains(지금) || !!지금.closest('.tooltip-content')) {
-                const 단추 = returnToRef.current();
-                if (단추) {
+            const active = document.activeElement;
+            if (!active || active === document.body || !document.contains(active) || !!active.closest('.tooltip-content')) {
+                const returnButton = returnToRef.current();
+                if (returnButton) {
                     try {
-                        단추.focus();
+                        returnButton.focus();
                     }
                     catch (e) { /* 떼어진 노드 */ }
                 }

package/dist/packages/core/src/components/Training/useNoiseFade.js

@@ -38,7 +38,7 @@ export function useNoiseFade({ noisePlayer, audioRef, playbackStateRef, sequence
     /* **"지금 시간표가 도는가" 는 진행기에게 묻는다**((85) 2c, 2026-10-06). 전에는 자리를
        받아 **제 손으로 셈했다**(`p.phase !== 'sound' && p.at > 0`) — 같은 셈이 틱·토글·여기
        세 벌이었다. 셈이 한 자리에 있어야 "뜸이란 무엇인가" 가 갈라지지 않는다. */
-    const 뜸중 = useCallback(() => !!sequencer?.isRunning(), [sequencer]);
+    const inPad = useCallback(() => !!sequencer?.isRunning(), [sequencer]);
     const cancelNoiseFade = useCallback(() => {
         if (noiseFadeRafRef.current !== null) {
             cancelAnimationFrame(noiseFadeRafRef.current);
@@ -215,7 +215,7 @@ export function useNoiseFade({ noisePlayer, audioRef, playbackStateRef, sequence
                `뜸중()` 만 지워도 시험 108 개가 다 통과한다. 둘이 같은 뜻이 아니라 **오늘 같이
                갈 뿐**이라 남겨 둔다. 지우려면 "뜸이면 playbackState 가 'playing' 이다" 를 먼저
                문으로 세워라 — 안 세우고 지우면 다음에 그 하나가 안 따라간다. */
-            if (mainPlaying || 뜸중() || playbackStateRef.current === 'playing') {
+            if (mainPlaying || inPad() || playbackStateRef.current === 'playing') {
                 misses = 0;
                 return;
             }
@@ -226,7 +226,7 @@ export function useNoiseFade({ noisePlayer, audioRef, playbackStateRef, sequence
             }
         }, 400);
         return () => clearInterval(iv);
-    }, [fadeOutNoise, noiseInUse, audioRef, playbackStateRef, 뜸중]);
+    }, [fadeOutNoise, noiseInUse, audioRef, playbackStateRef, inPad]);
     // 탭 백그라운드 전환 시 소음 즉시 정지 — 백그라운드 탭에서는 requestAnimationFrame이
     // 멈추거나 크게 스로틀돼 fadeOutNoise의 볼륨 램프가 완주하지 못할 수 있어, 페이드 없이
     // 바로 pause한다.
@@ -249,14 +249,14 @@ export function useNoiseFade({ noisePlayer, audioRef, playbackStateRef, sequence
             if (!noiseEl || !noiseEl.paused)
                 return;
             const a = audioRef.current;
-            const mainPlaying = (!!a && !a.paused && !a.ended) || 뜸중() || playbackStateRef.current === 'playing';
-            const 지금 = noiseSettingsRef.current;
-            if (mainPlaying && 지금?.enabled && 지금.volume > 0)
-                fadeInNoise(지금.volume);
+            const mainPlaying = (!!a && !a.paused && !a.ended) || inPad() || playbackStateRef.current === 'playing';
+            const current = noiseSettingsRef.current;
+            if (mainPlaying && current?.enabled && current.volume > 0)
+                fadeInNoise(current.volume);
         };
         document.addEventListener('visibilitychange', handleVisibilityChange);
         return () => document.removeEventListener('visibilitychange', handleVisibilityChange);
-    }, [cancelNoiseFade, fadeInNoise, audioRef, playbackStateRef, 뜸중]);
+    }, [cancelNoiseFade, fadeInNoise, audioRef, playbackStateRef, inPad]);
     // noiseSettingsRef 최신화 (재생 이벤트 핸들러 클로저에서 사용)
     useEffect(() => {
         noiseSettingsRef.current = noisePlayer
@@ -264,8 +264,8 @@ export function useNoiseFade({ noisePlayer, audioRef, playbackStateRef, sequence
             : null;
     }, [noisePlayer, noisePlayer?.settings.enabled, noiseVolume, noisePlayer?.settings.type]);
     /* 새 소음 파일의 canplay 를 기다리는 핸들러 — 다음 종류 변경·떠날 때 뗀다(옛 파일 기다림이 새 설정 위에서 울리지 않게) */
-    const canplay떼기Ref = useRef(null);
-    useEffect(() => () => { canplay떼기Ref.current?.(); canplay떼기Ref.current = null; }, []);
+    const canplayOffRef = useRef(null);
+    useEffect(() => () => { canplayOffRef.current?.(); canplayOffRef.current = null; }, []);
     // 소음 설정 변경 → 오디오 반영
     useEffect(() => {
         const ns = noisePlayer?.settings;
@@ -292,24 +292,24 @@ export function useNoiseFade({ noisePlayer, audioRef, playbackStateRef, sequence
                     noiseEl.src = url;
                     noiseEl.load();
                     const mainAudio = audioRef.current;
-                    if ((mainAudio && !mainAudio.paused) || 뜸중()) {
-                        canplay떼기Ref.current?.();
+                    if ((mainAudio && !mainAudio.paused) || inPad()) {
+                        canplayOffRef.current?.();
                         const h = () => {
                             noiseEl.removeEventListener('canplay', h);
-                            if (canplay떼기Ref.current === 떼기)
-                                canplay떼기Ref.current = null;
+                            if (canplayOffRef.current === off)
+                                canplayOffRef.current = null;
                             // 파일 로드가 끝난 "이 시점"에 메인이 여전히 재생 중인지 재확인 —
                             // 로드가 느리면 예약 시점과 실행 시점 사이에 메인이 끝났을 수 있다.
                             /* 볼륨·켜짐은 **지금** 설정으로 — 효과 때 붙잡은 값으로 켜면, 불러오는 동안 치료사가 비율을 0.3 으로 내렸거나 소음을
                                껐어도 canplay 에서 1 로 다시 켜져 끝까지 났다(난이도가 뜻보다 어려워지고 기록과 들린 소리가 어긋남). */
                             const cur = audioRef.current;
-                            const 지금 = noiseSettingsRef.current;
-                            const 도나 = (!!cur && !cur.paused && !cur.ended) || 뜸중();
-                            if (도나 && 지금?.enabled && 지금.volume > 0)
-                                fadeInNoise(지금.volume);
+                            const current = noiseSettingsRef.current;
+                            const running = (!!cur && !cur.paused && !cur.ended) || inPad();
+                            if (running && current?.enabled && current.volume > 0)
+                                fadeInNoise(current.volume);
                         };
-                        const 떼기 = () => noiseEl.removeEventListener('canplay', h);
-                        canplay떼기Ref.current = 떼기;
+                        const off = () => noiseEl.removeEventListener('canplay', h);
+                        canplayOffRef.current = off;
                         noiseEl.addEventListener('canplay', h);
                     }
                 });
@@ -324,7 +324,7 @@ export function useNoiseFade({ noisePlayer, audioRef, playbackStateRef, sequence
             const mainAudio = audioRef.current;
             // speechSynthesis TTS 경로는 메인 <audio> 없이 재생된다 — 감시 타이머처럼 playbackState 도 본다(안 보면 비율만 바꿔도 소음이 멈췄다)
             // `뜸중()` 은 여기서도 겹옷이다 — 위 감시 타이머 옆 주석 참고.
-            const mainPlaying = (!!mainAudio && !mainAudio.paused && !mainAudio.ended) || 뜸중() || playbackStateRef.current === 'playing';
+            const mainPlaying = (!!mainAudio && !mainAudio.paused && !mainAudio.ended) || inPad() || playbackStateRef.current === 'playing';
             if (mainPlaying && pendingNoiseUrlRef.current) {
                 /* 종류를 바꾼 뒤 150ms 페이드아웃 안에 다른 설정을 바꾸면, 아래 볼륨만 옮기는 갈래가 파일을 바꿀 페이드를 지워 화면의 종류와
                    들리는 종류가 문장 끝까지 달랐다 — 기다리는 파일이 있으면 fadeInNoise 가 그것을 끼운다. */
@@ -358,7 +358,7 @@ export function useNoiseFade({ noisePlayer, audioRef, playbackStateRef, sequence
                 }
             }
         }
-    }, [noisePlayer?.settings, noisePlayer?.settings.enabled, noiseVolume, noisePlayer?.settings.type, cancelNoiseFade, fadeInNoise, fadeOutNoise, audioRef, playbackStateRef, noiseSettingsRef, 뜸중]);
+    }, [noisePlayer?.settings, noisePlayer?.settings.enabled, noiseVolume, noisePlayer?.settings.type, cancelNoiseFade, fadeInNoise, fadeOutNoise, audioRef, playbackStateRef, noiseSettingsRef, inPad]);
     // 소음 재생 속도(playbackRate) 반영 — 0.75~1.25. 엘리먼트 속성이라 src 변경에도 유지됨
     useEffect(() => {
         const el = noiseAudioRef.current;

package/dist/packages/core/src/components/Training/useObjectUrls.js

@@ -29,9 +29,9 @@ export function useObjectUrls() {
     }, []);
     /** 계속 쓸 것만 남기고 나머지는 되돌려준다 */
     const keepOnly = useCallback((keep) => {
-        const 남길것 = new Set([...keep].filter(Boolean));
+        const keepSet = new Set([...keep].filter(Boolean));
         urlsRef.current = urlsRef.current.filter(u => {
-            if (남길것.has(u))
+            if (keepSet.has(u))
                 return true;
             try {
                 URL.revokeObjectURL(u);

package/dist/packages/core/src/components/Training/usePlaybackSequencer.d.ts

@@ -31,7 +31,7 @@ export interface SequencerPosition {
 /** 뜸에서 멈춘 자리 — **어느 뜸의 몇 ms 지점**이었나. 이을 때 남은 만큼만 채우는 데 쓴다 */
 export interface SequencerPause {
     phase: Exclude<PadPhase, 'sound'>;
-    흐른: number;
+    elapsed: number;
 }
 export interface PlaybackSequencer {
     /** 틱·소음·토글이 읽는다 — 매 틀 읽히므로 ref 다 */
@@ -85,7 +85,7 @@ export interface PlaybackSequencer {
      * 자리만 그만큼 **뒤로 밀어 둔다** — 그래야 재생바가 멈춘 값에서 이어진다. 안 밀면 남은
      * 시간만 기다리면서 바는 0 부터 다시 긴다(그 어긋남이 (90)·(91) 의 튐이었다).
      */
-    waitPad: (ms: number, phase: Exclude<PadPhase, 'sound'>, 이미흐른?: number) => Promise<boolean>;
+    waitPad: (ms: number, phase: Exclude<PadPhase, 'sound'>, alreadyElapsed?: number) => Promise<boolean>;
     /** 소리 구간으로 들어간다 */
     enterSound: () => void;
     /**

package/dist/packages/core/src/components/Training/usePlaybackSequencer.js

@@ -2,8 +2,8 @@
 import { useCallback, useEffect, useMemo, useRef } from 'react';
 export function usePlaybackSequencer({ mountedRef }) {
     const positionRef = useRef({ phase: 'sound', at: 0 });
-    const 세대Ref = useRef(0);
-    const 뜸타이머Ref = useRef(null);
+    const generationRef = useRef(0);
+    const padTimerRef = useRef(null);
     /**
      * **그만둘 때 타이머를 걷지 않는다 — 세대로 가린다.**
      *
@@ -19,45 +19,45 @@ export function usePlaybackSequencer({ mountedRef }) {
      * 걷어 버리면 세대를 볼 일이 없다. 둘 중 하나를 골라야 하는 자리였다.)
      */
     /** 멈출 때의 자리 — 어느 뜸의 몇 ms 지점이었나. 뜸에서 안 멈췄으면 `null` */
-    const 멈춘자리Ref = useRef(null);
+    const pausedAtRef = useRef(null);
     /* **`abort()` 보다 먼저 부른다** — `abort()` 는 자리를 비우므로 뒤에 부르면 "어느 구간에서
        멈췄나" 를 이미 잃는다. `pause()` 가 그 자리를 보고 적고, 그다음에 `abort()` 가 걷는다.
        (`abort()` 가 이 적바림까지 지우게 했다가 못이 울렸다 — 멈춘 자리를 바로 지워 버려
        이을 때 앞 소리가 또 났다. `멈춤의도()` 안에서 둘이 잇따라 불린다.) */
     const pause = useCallback(() => {
         const p = positionRef.current;
-        const 뜸중 = p.phase !== 'sound' && p.at > 0;
+        const inPad = p.phase !== 'sound' && p.at > 0;
         /* **타이머는 안 걷는다** — 위 긴 설명 그대로다. 걷으면 약속이 안 풀려 뒷정리가 통째로
            안 돈다. 바로 뒤따르는 `abort()` 가 세대를 올리므로 돌던 뜸은 깨어나 거짓을 받고
            조용히 물러난다. 여기서는 **어디까지 갔었나**만 적는다. */
-        멈춘자리Ref.current = 뜸중
-            ? { phase: p.phase, 흐른: Math.max(0, Date.now() - p.at) }
+        pausedAtRef.current = inPad
+            ? { phase: p.phase, elapsed: Math.max(0, Date.now() - p.at) }
             : null;
     }, []);
     const resume = useCallback(() => {
-        const v = 멈춘자리Ref.current;
-        멈춘자리Ref.current = null;
+        const v = pausedAtRef.current;
+        pausedAtRef.current = null;
         return v;
     }, []);
     const abort = useCallback(() => {
-        세대Ref.current += 1;
+        generationRef.current += 1;
         positionRef.current = { phase: 'sound', at: 0 };
     }, []);
-    const waitPad = useCallback((ms, phase, 이미흐른 = 0) => {
+    const waitPad = useCallback((ms, phase, alreadyElapsed = 0) => {
         if (!(ms > 0))
             return Promise.resolve(true);
-        const 내세대 = 세대Ref.current;
+        const myGeneration = generationRef.current;
         /* 자리를 **이미 흐른 만큼 뒤로 밀어 둔다** — 재생바가 그 값에서 이어진다(위 설명) */
-        positionRef.current = { phase, at: Date.now() - Math.max(0, 이미흐른) };
+        positionRef.current = { phase, at: Date.now() - Math.max(0, alreadyElapsed) };
         return new Promise((res) => {
-            const 내타이머 = setTimeout(() => {
-                if (뜸타이머Ref.current === 내타이머)
-                    뜸타이머Ref.current = null;
+            const myTimer = setTimeout(() => {
+                if (padTimerRef.current === myTimer)
+                    padTimerRef.current = null;
                 /* **깨어날 때 제 세대인지 본다.** 앞 기다림을 안 걷으므로 둘이 함께 깨어날 수 있는데,
                    그때 낡은 쪽은 거짓을 받고 조용히 물러난다 — 사슬이 겹치지 않는 자리가 여기다. */
-                res(!!mountedRef.current && 내세대 === 세대Ref.current);
+                res(!!mountedRef.current && myGeneration === generationRef.current);
             }, ms);
-            뜸타이머Ref.current = 내타이머;
+            padTimerRef.current = myTimer;
         });
     }, [mountedRef]);
     const enterSound = useCallback(() => { positionRef.current = { phase: 'sound', at: Date.now() }; }, []);
@@ -68,14 +68,14 @@ export function usePlaybackSequencer({ mountedRef }) {
         const p = positionRef.current;
         return p.phase !== 'sound' && p.at > 0;
     }, []);
-    const generation = useCallback(() => 세대Ref.current, []);
-    const isCurrent = useCallback((gen) => gen === 세대Ref.current, []);
-    const __bumpGenerationForTest = useCallback(() => { 세대Ref.current += 1; }, []);
+    const generation = useCallback(() => generationRef.current, []);
+    const isCurrent = useCallback((gen) => gen === generationRef.current, []);
+    const __bumpGenerationForTest = useCallback(() => { generationRef.current += 1; }, []);
     /* 화면을 떠나면 반드시 걷는다 — 마지막 그물 */
     useEffect(() => () => {
-        if (뜸타이머Ref.current) {
-            clearTimeout(뜸타이머Ref.current);
-            뜸타이머Ref.current = null;
+        if (padTimerRef.current) {
+            clearTimeout(padTimerRef.current);
+            padTimerRef.current = null;
         }
     }, []);
     /**