@ihabdevteam/core 0.292.0 → 0.294.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.292.0";
+export declare const CORE_VERSION = "0.294.0";
 
 /** @public */
 declare const coreDefault: Record<string, unknown>;
@@ -10483,6 +10483,39 @@ export declare interface WordFilterSnapshot {
     wordTypeFilter?: string[];
 }
 
+/**
+ * @public **자리(어두·어중·어말)를 음절이 아니라 자음에 매긴다** — 말귀 요청 (93), 2026-10-06.
+ *
+ * `wordHasSyllableMatching` 의 위치 제약은 **음절 색인**으로 가른다(0번=어두 · 마지막=어말 ·
+ * 그 사이=어중). 그러면 **2음절 낱말에는 어중이 아예 없다** — `선물` 의 ㄴ받침·ㅁ초성을
+ * 뽑을 길이 없어 검색이 자료의 일부에 못 닿았다(말귀 두 화면이 2음절 이하면 어중 단추를
+ * 잠가 두고 있었다).
+ *
+ * 임상에서 쓰는 모델은 자리를 **자음에만** 매긴다(김동민 팀장·사공정희 선생, 2026-10-06):
+ *
+ *     선물 → ㅅ 어두초성 · ㄴ 어중종성 · ㅁ 어중초성 · ㄹ 어말종성
+ *     아기 → ㄱ 어중초성   (어두초성 없음 — `ㅇ` 은 음가가 없다 · 어말종성 없음)
+ *
+ *     어두 = 첫 음절의 **초성**(`ㅇ` 이면 **없는 것**으로 본다)
+ *     어말 = 마지막 음절의 **받침**(없으면 없는 것)
+ *     어중 = 그 밖의 **모든 초성·종성** — **2음절에도 생긴다**
+ *     중성(모음)에는 자리를 **안 매긴다** — 그래서 이 함수는 `jung` 을 안 받는다
+ *
+ * **`mid` 에서 `cho` 와 `jong` 을 둘 다 주면 둘 다 있어야 한다**(AND, 사용자 결정). `선물`
+ * 처럼 **받침+다음 초성**이 맞물리는 자음동화 꼴을 잡으려는 것이다. 다만 **붙어 있어야
+ * 하는 것은 아니다** — 낱말 어디에든 하나씩 있으면 된다. 하나만 주면 그것만 본다.
+ *
+ * `wordHasSyllableMatching` 은 **그대로 둔다** — 위치가 `무관` 일 때는 초성·중성·종성을
+ * **한 음절 안에서** 묶어 보는 것이 맞다(`ㄱ+ㅏ+ㅇ` = `강`). 두 함수는 묻는 것이 다르다.
+ */
+export declare function wordHasConsonantAt(word: string, parts: {
+    cho?: string[] | null;
+    jong?: string[] | null;
+    jongNone?: boolean;
+}, position: 'head' | 'mid' | 'tail', 
+/** 종성을 무엇으로 견줄지 — `wordHasSyllableMatching` 과 같다(`JongMatch` 참고) */
+jongMatch?: JongMatch): boolean;
+
 /** @public 단어의 모든 한글 음절에 종성(받침)이 없는지 (열린 음절로만 구성) */
 export declare function wordHasNoCoda(word: string): boolean;
 

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

@@ -339,7 +339,7 @@ export default function TrainingStepAudioPlayer({ btnLabel, soundSrc, bucketPath
         }
         setFillCompletionPhase('idle');
     }, []);
-    const tryPlayWithRetry = useCallback(async (a, attempts = 3, delayMs = 50) => {
+    const tryPlayWithRetry = useCallback(async (a, attempts = 3, delayMs = 50, 앞뜸흐른 = 0) => {
         /* 지난 완료의 접는 연출을 먼저 걷는다 — 위 설명 참고 */
         완료연출걷기();
         const 내세대 = 진행기.generation();
@@ -357,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)
@@ -380,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;
@@ -422,6 +425,39 @@ export default function TrainingStepAudioPlayer({ btnLabel, soundSrc, bucketPath
         catch (_) { }
         return false;
     }, [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)
@@ -926,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");

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/utils/koreanSyllable.d.ts

@@ -93,6 +93,38 @@ export declare function wordHasSyllableMatching(word: string, parts: {
 /** 종성을 무엇으로 견줄지 — 기본은 **글자 그대로**(`'glyph'`). 받침 **소리**로 모으려면 `'phoneme'`(`JongMatch` 참고).
  *  발음 입력 화면은 넘기는 낱말 자체가 표준발음이라 겹받침이 안 나온다 — 기본 그대로 두면 된다. */
 jongMatch?: JongMatch): boolean;
+/**
+ * @public **자리(어두·어중·어말)를 음절이 아니라 자음에 매긴다** — 말귀 요청 (93), 2026-10-06.
+ *
+ * `wordHasSyllableMatching` 의 위치 제약은 **음절 색인**으로 가른다(0번=어두 · 마지막=어말 ·
+ * 그 사이=어중). 그러면 **2음절 낱말에는 어중이 아예 없다** — `선물` 의 ㄴ받침·ㅁ초성을
+ * 뽑을 길이 없어 검색이 자료의 일부에 못 닿았다(말귀 두 화면이 2음절 이하면 어중 단추를
+ * 잠가 두고 있었다).
+ *
+ * 임상에서 쓰는 모델은 자리를 **자음에만** 매긴다(김동민 팀장·사공정희 선생, 2026-10-06):
+ *
+ *     선물 → ㅅ 어두초성 · ㄴ 어중종성 · ㅁ 어중초성 · ㄹ 어말종성
+ *     아기 → ㄱ 어중초성   (어두초성 없음 — `ㅇ` 은 음가가 없다 · 어말종성 없음)
+ *
+ *     어두 = 첫 음절의 **초성**(`ㅇ` 이면 **없는 것**으로 본다)
+ *     어말 = 마지막 음절의 **받침**(없으면 없는 것)
+ *     어중 = 그 밖의 **모든 초성·종성** — **2음절에도 생긴다**
+ *     중성(모음)에는 자리를 **안 매긴다** — 그래서 이 함수는 `jung` 을 안 받는다
+ *
+ * **`mid` 에서 `cho` 와 `jong` 을 둘 다 주면 둘 다 있어야 한다**(AND, 사용자 결정). `선물`
+ * 처럼 **받침+다음 초성**이 맞물리는 자음동화 꼴을 잡으려는 것이다. 다만 **붙어 있어야
+ * 하는 것은 아니다** — 낱말 어디에든 하나씩 있으면 된다. 하나만 주면 그것만 본다.
+ *
+ * `wordHasSyllableMatching` 은 **그대로 둔다** — 위치가 `무관` 일 때는 초성·중성·종성을
+ * **한 음절 안에서** 묶어 보는 것이 맞다(`ㄱ+ㅏ+ㅇ` = `강`). 두 함수는 묻는 것이 다르다.
+ */
+export declare function wordHasConsonantAt(word: string, parts: {
+    cho?: string[] | null;
+    jong?: string[] | null;
+    jongNone?: boolean;
+}, position: 'head' | 'mid' | 'tail', 
+/** 종성을 무엇으로 견줄지 — `wordHasSyllableMatching` 과 같다(`JongMatch` 참고) */
+jongMatch?: JongMatch): boolean;
 /**
  * @public 문자열이 음절 패턴 DSL 문법인지 — 쉼표(,) 포함 여부로 판별한다.
  * 일반 단어 검색어엔 쉼표가 쓰이지 않으므로 충돌 없이 자동 분기할 수 있다.

package/dist/packages/core/src/utils/koreanSyllable.js

@@ -337,6 +337,72 @@ jongMatch = 'glyph') {
             return true;
     return false;
 }
+/**
+ * @public **자리(어두·어중·어말)를 음절이 아니라 자음에 매긴다** — 말귀 요청 (93), 2026-10-06.
+ *
+ * `wordHasSyllableMatching` 의 위치 제약은 **음절 색인**으로 가른다(0번=어두 · 마지막=어말 ·
+ * 그 사이=어중). 그러면 **2음절 낱말에는 어중이 아예 없다** — `선물` 의 ㄴ받침·ㅁ초성을
+ * 뽑을 길이 없어 검색이 자료의 일부에 못 닿았다(말귀 두 화면이 2음절 이하면 어중 단추를
+ * 잠가 두고 있었다).
+ *
+ * 임상에서 쓰는 모델은 자리를 **자음에만** 매긴다(김동민 팀장·사공정희 선생, 2026-10-06):
+ *
+ *     선물 → ㅅ 어두초성 · ㄴ 어중종성 · ㅁ 어중초성 · ㄹ 어말종성
+ *     아기 → ㄱ 어중초성   (어두초성 없음 — `ㅇ` 은 음가가 없다 · 어말종성 없음)
+ *
+ *     어두 = 첫 음절의 **초성**(`ㅇ` 이면 **없는 것**으로 본다)
+ *     어말 = 마지막 음절의 **받침**(없으면 없는 것)
+ *     어중 = 그 밖의 **모든 초성·종성** — **2음절에도 생긴다**
+ *     중성(모음)에는 자리를 **안 매긴다** — 그래서 이 함수는 `jung` 을 안 받는다
+ *
+ * **`mid` 에서 `cho` 와 `jong` 을 둘 다 주면 둘 다 있어야 한다**(AND, 사용자 결정). `선물`
+ * 처럼 **받침+다음 초성**이 맞물리는 자음동화 꼴을 잡으려는 것이다. 다만 **붙어 있어야
+ * 하는 것은 아니다** — 낱말 어디에든 하나씩 있으면 된다. 하나만 주면 그것만 본다.
+ *
+ * `wordHasSyllableMatching` 은 **그대로 둔다** — 위치가 `무관` 일 때는 초성·중성·종성을
+ * **한 음절 안에서** 묶어 보는 것이 맞다(`ㄱ+ㅏ+ㅇ` = `강`). 두 함수는 묻는 것이 다르다.
+ */
+export function wordHasConsonantAt(word, parts, position, 
+/** 종성을 무엇으로 견줄지 — `wordHasSyllableMatching` 과 같다(`JongMatch` 참고) */
+jongMatch = 'glyph') {
+    if (!word)
+        return false;
+    const 음절 = [...word].map(parseSyllable).filter((s) => !!s);
+    if (음절.length === 0)
+        return false;
+    const 끝 = 음절.length - 1;
+    if (position === 'head') {
+        /* 어두는 **첫 음절의 초성**뿐이다. `ㅇ` 은 음가가 없어 자리를 안 가진다 —
+           `아기` 의 어두초성은 **없다**(`cho: ['ㅇ']` 로 물으면 거짓). */
+        if (!parts.cho)
+            return false;
+        const c = CHOSEONG[음절[0].cho];
+        return c !== 'ㅇ' && parts.cho.includes(c);
+    }
+    if (position === 'tail') {
+        /* 어말은 **마지막 받침**뿐이다. 받침이 없으면 자리가 없다. */
+        if (parts.jongNone)
+            return 음절[끝].jong === 0;
+        if (!parts.jong)
+            return false;
+        return syllableJongMatches(음절[끝], parts.jong, jongMatch);
+    }
+    /* 어중 — 첫 초성과 마지막 종성을 **뺀** 나머지 자음 전부. 2음절 `선물` 이면
+       ㄴ(0번 종성) · ㅁ(1번 초성) 둘이 어중이다. */
+    const 초성맞나 = !parts.cho || 음절.some((s, i) => {
+        if (i === 0)
+            return false; // 첫 초성은 어두다
+        const c = CHOSEONG[s.cho];
+        return c !== 'ㅇ' && parts.cho.includes(c); // 음가 없는 ㅇ 은 자리를 안 가진다
+    });
+    const 종성맞나 = parts.jongNone
+        ? 음절.some((s, i) => i !== 끝 && s.jong === 0)
+        : !parts.jong || 음절.some((s, i) => i !== 끝 && syllableJongMatches(s, parts.jong, jongMatch));
+    /* 둘 다 줬으면 **둘 다** 있어야 한다(AND) — 하나만 줬으면 그쪽만 참이면 된다 */
+    if (!parts.cho && !parts.jong && !parts.jongNone)
+        return false;
+    return 초성맞나 && 종성맞나;
+}
 /**
  * @public 문자열이 음절 패턴 DSL 문법인지 — 쉼표(,) 포함 여부로 판별한다.
  * 일반 단어 검색어엔 쉼표가 쓰이지 않으므로 충돌 없이 자동 분기할 수 있다.

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

@@ -51,7 +51,7 @@ export type { TrainingCounts, ComputeDailySelectionOptions } from './utils/getTr
 export { TRAINING_TYPES, TOPIC_TYPES, TRAINING_TYPE_I18N_KEY } from './utils/CategoryData';
 export type { WordEntry } from './utils/phonemePairSearch';
 export { CAPABILITY, isValidQuestionWord, hasQuestionWordConstraint, isManualOnlyType } from './utils/wordTrainingRuntime';
-export { wordContainsChoseong, wordContainsJungseong, wordContainsJongseong, wordHasNoCoda, wordHasSyllableMatching, syllableLength } from './utils/koreanSyllable';
+export { wordContainsChoseong, wordContainsJungseong, wordContainsJongseong, wordHasNoCoda, wordHasSyllableMatching, wordHasConsonantAt, syllableLength } from './utils/koreanSyllable';
 export { isSyllablePattern, matchesSyllablePattern, validateSyllableSearchInput, patternToComposition, matchesWordQuery, searchAndRankWords } from './utils/koreanSyllable';
 export { PLAN_FEATURES, PLAN_LIMITS, TIER_RANK, getPlanTier, isManagerTier, type PlanTier, type DataLevel, type PlanFeatures, type PlanLimits, } from './utils/planFeatures';
 export { WORD_SUGGESTION_WEEKLY_QUOTA, WORD_SUGGESTION_ACCOUNT_LIMIT, WORD_SUGGESTION_EXISTING_ERROR, isThisWeekPick, } from './utils/wordSuggestionPolicy';

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

@@ -34,7 +34,7 @@ export { classifyPairDifficulty, firstChoseongOf, toChoseong, isAllChoseong, mat
 export { ensureTrainingDataLoaded, getTrainingPools, loadTrainingData, isTrainingDataLoaded, getDailySelection, computeDailySelection, NOISE_DATAS, SHORT_STORIES, LONG_STORIES, ORDER_SETS } from './utils/getTrainingData';
 export { TRAINING_TYPES, TOPIC_TYPES, TRAINING_TYPE_I18N_KEY } from './utils/CategoryData';
 export { CAPABILITY, isValidQuestionWord, hasQuestionWordConstraint, isManualOnlyType } from './utils/wordTrainingRuntime';
-export { wordContainsChoseong, wordContainsJungseong, wordContainsJongseong, wordHasNoCoda, wordHasSyllableMatching, syllableLength } from './utils/koreanSyllable';
+export { wordContainsChoseong, wordContainsJungseong, wordContainsJongseong, wordHasNoCoda, wordHasSyllableMatching, wordHasConsonantAt, syllableLength } from './utils/koreanSyllable';
 export { isSyllablePattern, matchesSyllablePattern, validateSyllableSearchInput, patternToComposition, matchesWordQuery, searchAndRankWords } from './utils/koreanSyllable';
 /* 요금제 정의 — 회원앱과 말귀어드민이 둘 다 본다. 예전에는 회원앱(src/libs) 안에 있었고
    어드민이 '@app/libs/planFeatures' 로 끌어다 썼는데, 그 한 줄 때문에 어드민이 회원앱

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

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

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

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