@ihabdevteam/core 0.291.0 → 0.293.0

package/dist/ihabdevteam-core.d.ts

@@ -1651,7 +1651,7 @@ export declare function copyText(text: string): Promise<boolean>;
  *
  * 값은 손으로 적고 `test/coreVersion.test.ts` 가 package.json 과 어긋나면 운다.
  */
-export declare const CORE_VERSION = "0.291.0";
+export declare const CORE_VERSION = "0.293.0";
 
 /** @public */
 declare const coreDefault: Record<string, unknown>;

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

@@ -315,7 +315,33 @@ export default function TrainingStepAudioPlayer({ btnLabel, soundSrc, bucketPath
         a.load();
         빠르기걸기(a); // 되돌린 뒤 한 번 더 — 기본값을 못 세우는 환경에서도 선다
     }, [빠르기걸기]);
-    const tryPlayWithRetry = useCallback(async (a, attempts = 3, delayMs = 50) => {
+    /**
+     * **완료 연출을 걷는다** — 새 재생이 서면 지난 완료의 자취가 그 위에 남아선 안 된다.
+     *
+     * 다 들으면 `handleEnd` 가 마커를 `hold`(200ms) → `out`(340ms) 로 접고, 그 끝에서
+     * `onDone(true)` 를 낸다. 그 **540ms 안에** 다시듣기나 ▶ 를 누르면(사람이 가장 흔히 누르는
+     * 때다) 새 재생이 이미 마커를 0 에서 움직이는데, 접는 연출이 그 위에 `is-out` 을 붙여
+     * `opacity: 0 · scaleY: 0` 으로 **숨겼다가**(`forwards` 라 그 상태에 머문다) 끝나면 **툭
+     * 나타난다** — 사용자가 "튀면서 움직인다" 고 본 것이 이것이다(말귀 실측: 뒤뜸 끝 +60 ·
+     * +180 · +320ms 어느 때 눌러도 난다).
+     *
+     * 그리고 그 타이머 끝의 `onDone(true)` 가 **다시 듣는 중에** 한 번 더 나갔다. 이 갈래에서는
+     * 눈에 안 띄지만 단계를 넘기는 자리라면 **다시 듣는 중에 넘어간다.**
+     *
+     * 걷는 자리를 하나로 둔다 — 새 소리는 전부 `tryPlayWithRetry` 를 지나므로 거기서 한 번
+     * 부른다(다시듣기 · ▶ · 번호 단추 · 불러오기가 다 그 길이다). 걷는 곳이 여럿이면
+     * **한 곳이 안 따라간다** — 오늘 밤 내내 그 결이었다.
+     */
+    const 완료연출걷기 = useCallback(() => {
+        if (fillOutResetRef.current) {
+            clearTimeout(fillOutResetRef.current);
+            fillOutResetRef.current = null;
+        }
+        setFillCompletionPhase('idle');
+    }, []);
+    const tryPlayWithRetry = useCallback(async (a, attempts = 3, delayMs = 50, 앞뜸흐른 = 0) => {
+        /* 지난 완료의 접는 연출을 먼저 걷는다 — 위 설명 참고 */
+        완료연출걷기();
         const 내세대 = 진행기.generation();
         /* **이어 트는 것에는 앞뜸을 다시 안 준다**(사용자 신고, 2026-10-06).
            앞뜸은 *소리 앞*의 구간이다. 소리가 **이미 시작된** 것을 이어 트는데 앞뜸을 또 주면
@@ -331,7 +357,10 @@ export default function TrainingStepAudioPlayer({ btnLabel, soundSrc, bucketPath
            > 있다. 그러면 시간표를 *앞뜸 + 남은 소리 + 뒤뜸* 으로 다시 그려야 어긋나지 않는다.
            > 그것은 **사장님께 여쭐 일**이라 지금은 "앞뜸은 소리 앞" 이라는 뜻 그대로 둔다. */
         const 이어틀기 = !!a && a.currentTime > 0 && !a.ended;
-        if (leadInMsRef.current > 0 && !이어틀기) {
+        /* 앞뜸에서 멈췄다 이으면 **남은 만큼만** 채운다 — 뜸도 시간표의 일부라 처음부터 다시
+           세면 그 자리에서 이어지지 않는다(사용자 결정, 2026-10-06). */
+        const 남은앞뜸 = Math.max(0, leadInMsRef.current - Math.max(0, 앞뜸흐른));
+        if (남은앞뜸 > 0 && !이어틀기) {
             /* **스피커는 뜸이 시작될 때 잡는다**((85) 2b, 2026-10-06). 전에는 `await a.play()` 바로
                앞에서 잡았는데, 그러면 **앞뜸 내내 주인이 없다** — 그 사이 남이 소리를 내도 이쪽을
                못 멈추고, 뜸이 끝나면 둘이 함께 울린다. 소음은 이미 뜸부터 깔리니(0.268.0)
@@ -354,7 +383,7 @@ export default function TrainingStepAudioPlayer({ btnLabel, soundSrc, bucketPath
                 }
                 catch (e) { }
             }
-            if (!(await 진행기.waitPad(leadInMsRef.current, 'lead')))
+            if (!(await 진행기.waitPad(남은앞뜸, 'lead', 앞뜸흐른)))
                 return false;
             if (!mountedRef.current || !진행기.isCurrent(내세대))
                 return false;
@@ -395,7 +424,40 @@ export default function TrainingStepAudioPlayer({ btnLabel, soundSrc, bucketPath
         }
         catch (_) { }
         return false;
-    }, [t, startTicker, 진행기, fadeInNoise, noiseSettingsRef]);
+    }, [t, startTicker, 진행기, fadeInNoise, noiseSettingsRef, 완료연출걷기]);
+    /**
+     * **뒤뜸(사이 뜸)에서 멈췄다 이을 때** — 남은 만큼 돌고 하던 일을 잇는다.
+     *
+     * 전에는 그 뜸을 **건너뛰고** 바로 다음 소리로 갔다(마지막이면 즉시 완료). 그러면 사이가
+     * 짧아지고 재생바가 그 순간 튄다 — 사용자가 짚은 것이 그 자리다. `onEnded` 의 사슬과
+     * **같은 모양**이어야 하므로(진행바 켜기 · 소음 · 세대 가림 · `leave()`) 여기도 그대로 둔다.
+     */
+    const 뒤뜸이어가기 = useCallback((흐른) => {
+        const 내세대 = 진행기.generation();
+        const 남은 = Math.max(0, tailMsRef.current - Math.max(0, 흐른));
+        startTicker();
+        const ns = noiseSettingsRef.current;
+        if (ns?.enabled && (ns.volume ?? 0) > 0) {
+            try {
+                fadeInNoise(ns.volume);
+            }
+            catch (e) { }
+        }
+        const 잇기 = () => { try {
+            이어가기RefBox.current?.();
+        }
+        catch (e) { } };
+        if (남은 <= 0) {
+            진행기.leave();
+            잇기();
+            return;
+        }
+        진행기.waitPad(남은, 'tail', 흐른).then((이어도되나) => {
+            진행기.leave();
+            if (이어도되나 && 진행기.isCurrent(내세대))
+                잇기();
+        }).catch(() => { });
+    }, [진행기, startTicker, fadeInNoise, noiseSettingsRef]);
     const attachAudioListeners = useCallback(() => {
         const a = audioRef.current;
         if (!a)
@@ -900,19 +962,23 @@ export default function TrainingStepAudioPlayer({ btnLabel, soundSrc, bucketPath
             /* 뒤뜸에서 멈췄던 것이면 그 소리를 다시 틀지 않고 **그다음으로** 잇는다 — 끝난 요소에
                `play()` 를 걸면 방금 들은 소리가 처음부터 또 난다. 뜸은 이미 한 번 기다렸으니
                다시 세지 않는다. */
-            /* **멈춘 자리에서 이어 간다** — 어디서 멈췄는지는 진행기가 안다.
-               `'restart'`(앞뜸이었다)면 아래로 흘러 처음부터 다시 돈다. */
-            const 이어갈것 = 진행기.resume();
-            if (typeof 이어갈것 === 'function') {
+            /* **멈춘 자리에서 이어 간다** — 어디서 몇 ms 였는지는 진행기가 안다.
+               뜸도 시간표의 일부라 **남은 만큼만** 채운다(사용자 결정, 2026-10-06). */
+            const 멈췄던곳 = 진행기.resume();
+            if (멈췄던곳) {
                 setPlaybackState("playing");
-                이어갈것();
+                if (멈췄던곳.phase === 'tail') {
+                    뒤뜸이어가기(멈췄던곳.흐른);
+                    return;
+                }
+                await tryPlayWithRetry(a, 3, 50, 멈췄던곳.흐른);
                 return;
             }
             await tryPlayWithRetry(a);
             setPlaybackState("playing");
         }
         else {
-            진행기.pause(이어가기RefBox.current);
+            진행기.pause();
             멈춤의도();
             a.pause();
             setPlaybackState("paused");
@@ -1243,6 +1309,8 @@ export default function TrainingStepAudioPlayer({ btnLabel, soundSrc, bucketPath
         if (disabledRef.current)
             return;
         try {
+            /* 앞 연출이 돌고 있으면 걷고 새로 건다 — 걷는 일은 `완료연출걷기` 하나가 안다
+               (여기서는 바로 아래에서 `hold` 를 다시 세우므로 `idle` 로 돌아가는 한 틱은 안 보인다). */
             if (fillOutResetRef.current) {
                 clearTimeout(fillOutResetRef.current);
                 fillOutResetRef.current = null;

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

@@ -28,6 +28,11 @@ export interface SequencerPosition {
     /** 그 구간이 시작한 때(`Date.now()`). `sound` 이거나 안 돌면 0 */
     at: number;
 }
+/** 뜸에서 멈춘 자리 — **어느 뜸의 몇 ms 지점**이었나. 이을 때 남은 만큼만 채우는 데 쓴다 */
+export interface SequencerPause {
+    phase: Exclude<PadPhase, 'sound'>;
+    흐른: number;
+}
 export interface PlaybackSequencer {
     /** 틱·소음·토글이 읽는다 — 매 틀 읽히므로 ref 다 */
     positionRef: React.RefObject<SequencerPosition>;
@@ -56,25 +61,31 @@ export interface PlaybackSequencer {
     /**
      * **멈춘 자리를 적어 둔다 — 다시 누르면 어디서부터인가.**
      *
-     * 멈출 때 `pause(이어가기)` 로 적고, 다시 누를 때 `resume()` 으로 묻는다. 답은 둘이다:
+     * 멈출 때 `pause()` 로 적고, 다시 누를 때 `resume()` 으로 묻는다. 답은 **어느 뜸의 몇 ms
+     * 자리였나** 다 — 그러면 부르는 쪽이 **남은 만큼만** 채우고 하던 일을 잇는다.
      *
-     *   `'restart'`  앞뜸에서 멈췄다 → **앞뜸부터 다시.** 앞뜸은 귀가 소음에 자리를 잡는
-     *                시간인데(0.268.0) 멈추면 소음도 멎으니, 남은 뜸만 채우면 그 시간이 잘린다.
-     *   `(함수)`     사이·뒤뜸에서 멈췄다 → **그 자리에서 이어 간다**(다음 소리로, 마지막이면
-     *                완료로). 끝난 요소에 `play()` 를 걸면 방금 들은 소리가 처음부터 또 난다.
+     * **뜸을 포함한 시간표가 한 시계다**(사용자 결정, 2026-10-06). 전에는 앞뜸이면 처음부터 다시,
+     * 사이·뒤뜸이면 그 뜸을 **건너뛰고** 다음으로였다 — 소리 구간만 제자리에서 이어지고 뜸
+     * 구간은 "다시" 아니면 "건너뜀" 이었다. 사용자가 짚은 것이 그 어긋남이다: *"앞 뒤 뜸을
+     * 고려한 시간으로 계산이 가능하도록 해야 앞 뒤에서 멈추더라도 그 자리에서 동일하게
+     * 재생될 것 같은데"*.
      *
      * 전에는 재생기가 ref 둘(`뒤뜸에서멈춤Ref` · `이어가기Ref`)로 들고 **멈추는 자리마다** 그
      * 둘을 맞춰 적어야 했다 — 네 자리 중 한 곳만 빠뜨려도 틀린 데서 이어 간다.
      * 어느 구간에서 멈췄는지는 **자리를 쥔 쪽**이 안다.
      */
-    pause: (resume: (() => void) | null) => void;
-    /** 멈춘 자리에서 이어 갈 방법. 멈춘 적이 없으면 `null` */
-    resume: () => 'restart' | (() => void) | null;
+    pause: () => void;
+    /** 멈춘 뜸 자리. 뜸에서 안 멈췄으면 `null` */
+    resume: () => SequencerPause | null;
     /**
      * 뜸만큼 기다린다. 그 사이 세대가 바뀌거나 화면을 떠나면 **거짓**을 준다 —
      * 부르는 쪽은 거짓이면 아무 일도 하지 않고 돌아간다.
+     *
+     * `이미흐른` 은 **이 뜸에서 이미 지나간 만큼**이다(이어 틀 때). 기다리는 시간은 `ms` 그대로고
+     * 자리만 그만큼 **뒤로 밀어 둔다** — 그래야 재생바가 멈춘 값에서 이어진다. 안 밀면 남은
+     * 시간만 기다리면서 바는 0 부터 다시 긴다(그 어긋남이 (90)·(91) 의 튐이었다).
      */
-    waitPad: (ms: number, phase: Exclude<PadPhase, 'sound'>) => Promise<boolean>;
+    waitPad: (ms: number, phase: Exclude<PadPhase, 'sound'>, 이미흐른?: number) => Promise<boolean>;
     /** 소리 구간으로 들어간다 */
     enterSound: () => void;
     /**

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

@@ -18,16 +18,21 @@ export function usePlaybackSequencer({ mountedRef }) {
      * (처음에는 걷는 쪽으로 썼다가, 그 때문에 **세대 비교가 죽은 코드**가 된 것을 뒤늦게 봤다 —
      * 걷어 버리면 세대를 볼 일이 없다. 둘 중 하나를 골라야 하는 자리였다.)
      */
-    /** 멈출 때의 자리 — `'restart'`(앞뜸이었다) 또는 이어 갈 함수, 안 멈췄으면 `null` */
+    /** 멈출 때의 자리 — 어느 뜸의 몇 ms 지점이었나. 뜸에서 안 멈췄으면 `null` */
     const 멈춘자리Ref = useRef(null);
     /* **`abort()` 보다 먼저 부른다** — `abort()` 는 자리를 비우므로 뒤에 부르면 "어느 구간에서
        멈췄나" 를 이미 잃는다. `pause()` 가 그 자리를 보고 적고, 그다음에 `abort()` 가 걷는다.
        (`abort()` 가 이 적바림까지 지우게 했다가 못이 울렸다 — 멈춘 자리를 바로 지워 버려
        이을 때 앞 소리가 또 났다. `멈춤의도()` 안에서 둘이 잇따라 불린다.) */
-    const pause = useCallback((resume) => {
+    const pause = useCallback(() => {
         const p = positionRef.current;
         const 뜸중 = p.phase !== 'sound' && p.at > 0;
-        멈춘자리Ref.current = !뜸중 ? null : p.phase === 'lead' ? 'restart' : resume;
+        /* **타이머는 안 걷는다** — 위 긴 설명 그대로다. 걷으면 약속이 안 풀려 뒷정리가 통째로
+           안 돈다. 바로 뒤따르는 `abort()` 가 세대를 올리므로 돌던 뜸은 깨어나 거짓을 받고
+           조용히 물러난다. 여기서는 **어디까지 갔었나**만 적는다. */
+        멈춘자리Ref.current = 뜸중
+            ? { phase: p.phase, 흐른: Math.max(0, Date.now() - p.at) }
+            : null;
     }, []);
     const resume = useCallback(() => {
         const v = 멈춘자리Ref.current;
@@ -38,11 +43,12 @@ export function usePlaybackSequencer({ mountedRef }) {
         세대Ref.current += 1;
         positionRef.current = { phase: 'sound', at: 0 };
     }, []);
-    const waitPad = useCallback((ms, phase) => {
+    const waitPad = useCallback((ms, phase, 이미흐른 = 0) => {
         if (!(ms > 0))
             return Promise.resolve(true);
         const 내세대 = 세대Ref.current;
-        positionRef.current = { phase, at: Date.now() };
+        /* 자리를 **이미 흐른 만큼 뒤로 밀어 둔다** — 재생바가 그 값에서 이어진다(위 설명) */
+        positionRef.current = { phase, at: Date.now() - Math.max(0, 이미흐른) };
         return new Promise((res) => {
             const 내타이머 = setTimeout(() => {
                 if (뜸타이머Ref.current === 내타이머)

package/dist/packages/core/src/version.d.ts

@@ -46,4 +46,4 @@
  *
  * 값은 손으로 적고 `test/coreVersion.test.ts` 가 package.json 과 어긋나면 운다.
  */
-export declare const CORE_VERSION = "0.291.0";
+export declare const CORE_VERSION = "0.293.0";

package/dist/packages/core/src/version.js

@@ -46,4 +46,4 @@
  *
  * 값은 손으로 적고 `test/coreVersion.test.ts` 가 package.json 과 어긋나면 운다.
  */
-export const CORE_VERSION = '0.291.0';
+export const CORE_VERSION = '0.293.0';