@ihabdevteam/core 0.133.0 → 0.135.0

package/dist/packages/core/src/hooks/useVisitHistory.js

@@ -1,5 +1,5 @@
 import { useState } from 'react';
-import { useEditableList } from './useEditableList';
+import { useEditableList, isSameEditableItem } from './useEditableList';
 /**
  * @public
  */
@@ -24,7 +24,7 @@ export function useVisitHistory(initialHistory = []) {
         closeSubPopup?.();
     };
     const handleVisitEditSave = () => {
-        commitEdit(prev => prev.map(v => v === selectedVisit ? editVisitForm : v), editVisitForm);
+        commitEdit(prev => prev.map(v => (selectedVisit != null && isSameEditableItem(v, selectedVisit)) ? editVisitForm : v), editVisitForm);
     };
     /** 외부(스케줄 훅 등)에서 방문이력에 항목을 추가할 때 사용 */
     const addVisit = (item) => {

package/dist/packages/core/src/hooks/useVisitSchedule.js

@@ -1,7 +1,7 @@
 'use client';
 import { useCallback, useMemo, useState } from 'react';
 import { today } from './useVisitHistory';
-import { useEditableList } from './useEditableList';
+import { useEditableList, isSameEditableItem } from './useEditableList';
 /**
  * 차례를 정하는 열쇠 — **가까운 것이 위**.
  *
@@ -48,17 +48,18 @@ initialSchedule = []) {
         closeSubPopup?.();
     };
     const handleScheduleEditSave = () => {
-        commitEdit(prev => sortByDate(prev.map(v => v === selectedSchedule ? editScheduleForm : v)), editScheduleForm);
+        commitEdit(prev => sortByDate(prev.map(v => (selectedSchedule != null && isSameEditableItem(v, selectedSchedule)) ? editScheduleForm : v)), editScheduleForm);
     };
     const handleScheduleDelete = useCallback((item) => {
         remove(item);
     }, [remove]);
     const handleScheduleToVisit = useCallback((item) => {
-        addVisit({ year: item.year, month: item.month, day: item.day, hour: item.hour, minute: item.minute, memo: item.memo });
+        // id 도 넘긴다 — 빠지면 그 방문을 이어서 수정할 때 합성 키로 넘어가 서버가 행을 못 찾았다
+        addVisit({ year: item.year, month: item.month, day: item.day, hour: item.hour, minute: item.minute, memo: item.memo, ...(item.id != null ? { id: item.id } : {}) });
         remove(item);
     }, [addVisit, remove]);
     const handleScheduleNoVisit = useCallback((item) => {
-        setScheduleList(prev => prev.filter(v => v !== item));
+        setScheduleList(prev => prev.filter(v => !isSameEditableItem(v, item)));
         setNoShowList(prev => [item, ...prev]);
         setSelectedSchedule(null);
     }, [setScheduleList, setSelectedSchedule]);

package/dist/packages/core/src/hooks/useWordMeanings.js

@@ -23,26 +23,35 @@ import { useState, useEffect, useMemo } from 'react';
 export const meaningKey = (word, homonum) => `${word}:${homonum ?? 1}`;
 // 세션 동안 유지되는 메모리 캐시 — 페이지를 오가도 재조회하지 않는다
 const memCache = new Map();
+/* 받아 봤는데 뜻이 없던 열쇠 — 다시 묻지 않는다. 전에는 뜻 없는 낱말이 캐시에 안 남아 표를 다시 정렬하거나 쪽을
+   넘길 때마다 같은 낱말을 또 조회했다. (조회가 실패한 것은 여기 넣지 않는다 — 다음에 다시 받는다.) */
+const noMeaning = new Set();
 export function useWordMeanings(rows, fetchMeanings) {
     /* 캐시는 모듈 스코프 Map 이라 갱신이 렌더에 자동 반영되지 않는다 — 조회가 끝나면 이 값을
        올려 아래 스냅샷을 다시 계산시킨다(캐시 히트만으로 리렌더가 연쇄되지 않도록 분리). */
     const [fetched, setFetched] = useState(0);
     // rows 는 매 렌더 새 배열이라 의존성으로 쓸 수 없다 — 조회 키만 뽑아 문자열로 비교한다
-    const wantedKey = rows.map(r => meaningKey(r.word, r.homonum)).join('|');
+    // 차례는 조회와 무관하다 — 정렬해 두어야 같은 낱말들을 다시 정렬만 해도 새 조회로 보지 않는다
+    const wantedKey = Array.from(new Set(rows.map(r => meaningKey(r.word, r.homonum)))).sort().join('|');
     useEffect(() => {
         const wanted = wantedKey ? wantedKey.split('|') : [];
-        const missing = wanted.filter(k => !memCache.has(k));
+        const missing = wanted.filter(k => !memCache.has(k) && !noMeaning.has(k));
         if (missing.length === 0)
             return; // 전부 캐시에 있음 — 네트워크·상태 갱신 불필요
         let cancelled = false;
         const words = Array.from(new Set(missing.map(k => k.slice(0, k.lastIndexOf(':')))));
         void fetchMeanings(words).then(got => {
-            if (cancelled || got.length === 0)
-                return;
+            /* 받은 것은 **취소됐어도 캐시에 담는다** — 쪽을 빨리 넘기면 앞 조회가 취소되며 받은 결과까지 버려, 돌아오면 또
+               조회했다. 화면 갱신(setFetched)만 취소된 쪽에서 건너뛴다. */
             for (const row of got) {
                 if (row.Meaning)
                     memCache.set(meaningKey(row.Word, row.Homonum ?? undefined), row.Meaning);
             }
+            for (const k of missing)
+                if (!memCache.has(k))
+                    noMeaning.add(k);
+            if (cancelled || got.length === 0)
+                return;
             setFetched(v => v + 1);
         }).catch(() => {
             // 조회 함수가 약속을 어기고 거절해도(망 끊김 등) 처리되지 않은 거절로 새지 않게 삼킨다 —

package/dist/packages/core/src/hooks/useWordTrainingFilter.js

@@ -85,10 +85,14 @@ export function useWordTrainingFilter(groupKey, caps, opts) {
     // 글자 모드에서 마지막으로 선택돼 있던 모음 자모 — 발음↔글자 왕복 시 병합 버튼(ㅔㅐ 등)의
     // 대표 자모로 뭉개지지 않고 원래 자모를 정확히 복원하기 위해 별도로 기억해 둔다.
     const lastCharJungRef = useRef(phonemeView === 'char' ? composition.jung : null);
+    // 종성도 — 발음은 대표음(ㅅ→ㄷ)으로 모으므로 되돌릴 원래 자모를 기억한다
+    const lastCharJongRef = useRef(phonemeView === 'char' ? composition.jong : null);
     useEffect(() => {
-        if (phonemeView === 'char')
+        if (phonemeView === 'char') {
             lastCharJungRef.current = composition.jung;
-    }, [phonemeView, composition.jung]);
+            lastCharJongRef.current = composition.jong;
+        }
+    }, [phonemeView, composition.jung, composition.jong]);
     // resetOnMount(단어훈련 만들기): '초기화'는 필터를 모두 비운 중립 상태여야 하므로 선택 토글도 OFF로 시작한다.
     // (기본 ON이면 단음절 음소 합치기 등에서 '이미지 있는 단어만'에 걸려 첫 진입 결과가 0이 된다.)
     // 단, 카드에 이미지가 필요한 타입(듣고 순서대로 기억하기 등)은 defaultImageOnly로 ON을 요청할 수 있다.
@@ -109,7 +113,8 @@ export function useWordTrainingFilter(groupKey, caps, opts) {
             return;
         resetKeyRef.current = opts?.resetKey;
         setComposition(seedComposition());
-        setExcludeNoImage(false);
+        // 이미지 토글도 그 타입의 기본값으로 — 무조건 false 로 두어 defaultImageOnly 를 요청한 타입(듣고 순서대로 기억하기)이 꺼졌다
+        setExcludeNoImage(!!opts?.defaultImageOnly);
         setSameStructureOnly(false);
         setGradeFilter([]);
         setPosFilter([]);
@@ -520,7 +525,7 @@ export function useWordTrainingFilter(groupKey, caps, opts) {
         if (next === phonemeView)
             return;
         if (next !== 'direct' && phonemeView !== 'direct') {
-            setComposition(c => convertComposition(c, next, lastCharJungRef.current));
+            setComposition(c => convertComposition(c, next, lastCharJungRef.current, lastCharJongRef.current));
         }
         setPhonemeView(next);
     }, [phonemeView]);

package/dist/packages/core/src/hooks/wordTrainingFilterModel.d.ts

@@ -51,7 +51,7 @@ export declare function charToPronValue(part: CompositionPart, jamo: string): st
  */
 export declare function pronToCharValue(part: CompositionPart, value: string, preferredJamo?: string | null): string;
 /** 모드 전환 시 composition의 초성/모음/종성을 대상 모드 값으로 변환. 종성 '없음'(NO_CODA)은 유지. */
-export declare function convertComposition(c: WordComposition, to: 'char' | 'pron', preferredCharJung?: string | null): WordComposition;
+export declare function convertComposition(c: WordComposition, to: 'char' | 'pron', preferredCharJung?: string | null, preferredCharJong?: string | null): WordComposition;
 /** 정답 단어 구성 선택 상태 (정답 단어에만 적용 — 오답은 대립 관계로 결정) */
 export interface WordComposition {
     cho: string | null;

package/dist/packages/core/src/hooks/wordTrainingFilterModel.js

@@ -83,10 +83,15 @@ export function pronToCharValue(part, value, preferredJamo) {
             return preferredJamo;
         return jamos[0] ?? value;
     }
+    /* 종성도 같다 — 글자→발음은 대표음(ㅅ·ㅈ·ㅊ·ㅌ·ㅎ → ㄷ, ㄳ → ㄱ)으로 모으므로, 되돌릴 때 전환 직전 글자 모드의 종성이
+       그 대표음에 속하면 그것을 복원한다. 전에는 대표음 그대로 돌아와 보기만 바꿔도 훈련 대상이 옷·낫에서 곧·받으로
+       바뀌어 저장됐다. */
+    if (part === 'jong' && preferredJamo && finalToPhoneme(preferredJamo) === value)
+        return preferredJamo;
     return value;
 }
 /** 모드 전환 시 composition의 초성/모음/종성을 대상 모드 값으로 변환. 종성 '없음'(NO_CODA)은 유지. */
-export function convertComposition(c, to, preferredCharJung) {
+export function convertComposition(c, to, preferredCharJung, preferredCharJong) {
     const conv = (part, v) => {
         if (!v)
             return null;
@@ -94,7 +99,7 @@ export function convertComposition(c, to, preferredCharJung) {
             return NO_CODA;
         if (to === 'pron')
             return charToPronValue(part, v);
-        return pronToCharValue(part, v, part === 'jung' ? preferredCharJung : null);
+        return pronToCharValue(part, v, part === 'jung' ? preferredCharJung : part === 'jong' ? preferredCharJong : null);
     };
     return { ...c, cho: conv('cho', c.cho), jung: conv('jung', c.jung), jong: conv('jong', c.jong) };
 }

package/dist/packages/core/src/i18n/locales/en.json

@@ -742,7 +742,8 @@
             "descriptionPlaceholder": "Enter a description for this word table.",
             "duplicateName": "This name is already in use.",
             "nameRequired": "Please enter a table name.",
-            "autoFillHint": " (Press Tab or Space to autofill)"
+            "autoFillHint": " (Press Tab or Space to autofill)",
+            "copyName": "{{name}} (copy)"
         },
         "loadTable": {
             "title": "Load Saved Word Table",
@@ -1390,5 +1391,16 @@
     },
     "loader": {
         "loading": "Loading"
+    },
+    "soundCompass": {
+        "state": {
+            "active": "playing",
+            "played": "heard",
+            "correct": "correct",
+            "wrong": "wrong"
+        }
+    },
+    "breadcrumb": {
+        "ariaLabel": "Breadcrumb"
     }
 }

package/dist/packages/core/src/i18n/locales/ko.json

@@ -740,7 +740,8 @@
             "descriptionPlaceholder": "이 단어표에 대한 설명을 입력하세요.",
             "duplicateName": "이미 사용 중인 이름입니다.",
             "nameRequired": "표 이름을 입력해 주세요.",
-            "autoFillHint": " (Tab 또는 space 입력시 자동 입력)"
+            "autoFillHint": " (Tab 또는 space 입력시 자동 입력)",
+            "copyName": "{{name}} (복사)"
         },
         "loadTable": {
             "title": "저장된 단어 표 불러오기",
@@ -1388,5 +1389,16 @@
     },
     "loader": {
         "loading": "불러오는 중…"
+    },
+    "soundCompass": {
+        "state": {
+            "active": "소리 나는 중",
+            "played": "들음",
+            "correct": "정답",
+            "wrong": "오답"
+        }
+    },
+    "breadcrumb": {
+        "ariaLabel": "이동 경로"
     }
 }

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

@@ -9,7 +9,23 @@ import { toKstYmd } from './date';
  * 입력에 대시가 있든 없든, 어떤 포맷이든 처리.
  */
 export function formatPhone(raw) {
-    const d = raw.replace(/\D/g, '').slice(0, 11);
+    const all = raw.replace(/\D/g, '');
+    /* **앞자리가 네 자리인 번호.** 050X 안심번호·0303 착신전환은 열두 자리까지 가고, 앞자리를 세 자리로 보면
+       `0507-1234-5678` 이 `050-7123-4567` 이 되어 **마지막 한 자리가 사라진 채** 멀쩡한 모양으로 저장됐다
+       (말귀가 formatPhoneKr 로 감싸 두었다 — 이제 걷어도 된다). */
+    if (/^(050\d|0303)/.test(all)) {
+        const d = all.slice(0, 12);
+        if (d.length <= 4)
+            return d;
+        if (d.length <= 8)
+            return `${d.slice(0, 4)}-${d.slice(4)}`;
+        return `${d.slice(0, 4)}-${d.slice(4, d.length - 4)}-${d.slice(d.length - 4)}`;
+    }
+    /* **대표번호**(1588·1544·1600·1899 …)는 여덟 자리 4-4 다 — 세 자리 앞자리로 보면 `158-8-1234` 가 됐다. */
+    if (/^1[5-9]\d{2}/.test(all) && all.length <= 8) {
+        return all.length <= 4 ? all : `${all.slice(0, 4)}-${all.slice(4)}`;
+    }
+    const d = all.slice(0, 11);
     if (d.startsWith('02')) {
         if (d.length <= 2)
             return d;

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

@@ -104,6 +104,9 @@ export async function loadTrainingData() {
             catch (e) { }
             return;
         }
+        /* 다 읽은 뒤에 한꺼번에 넣는다 — 도중에 형식 오류로 멈추면 이미 넣은 것이 남은 채 재시도가 또 넣어, 부를 때마다 풀에
+           중복이 쌓였다(하루 선택이 중복 문항을 뽑고 기기마다 세트가 달라짐). */
+        const 받음 = { noise: [], short: [], long: [], order: [] };
         try {
             for (const key of Object.keys(map || {})) {
                 const groups = map[key] || [];
@@ -115,16 +118,16 @@ export async function loadTrainingData() {
                     // Preserve original group structure from allTrainingData.json
                     const groupObj = Object.assign({}, gr, { training_type: t, category_0: cat0, category_1: cat1 });
                     if (t === 'LISTEN_IN_NOISE') {
-                        NOISE_DATAS.push(groupObj);
+                        받음.noise.push(groupObj);
                     }
                     else if (t === 'SHORT_STORY') {
-                        SHORT_STORIES.push(groupObj);
+                        받음.short.push(groupObj);
                     }
                     else if (t === 'LONG_STORY') {
-                        LONG_STORIES.push(groupObj);
+                        받음.long.push(groupObj);
                     }
                     else if (t === 'ORDERING_SENTENCE') {
-                        ORDER_SETS.push(groupObj);
+                        받음.order.push(groupObj);
                     }
                 }
             }
@@ -142,6 +145,10 @@ export async function loadTrainingData() {
             catch { /* SSR 등 */ }
             return;
         }
+        NOISE_DATAS.push(...받음.noise);
+        SHORT_STORIES.push(...받음.short);
+        LONG_STORIES.push(...받음.long);
+        ORDER_SETS.push(...받음.order);
         try {
             window.dispatchEvent(new Event('speechear.data.updated'));
         }

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

@@ -60,13 +60,16 @@ export async function checkImageExists(word, homonum) {
         return false;
     // 타임아웃 없으면 HEAD 요청 하나가 응답 없이 걸릴 때 이 확인을 기다리는
     // 검색 버튼(이미지 있음 필터)이 영구 비활성화된다
+    /* **확인이 안 된 것은 캐시하지 않는다.** 망 끊김·타임아웃·5xx 까지 '이미지 없음' 으로 영구 저장해, 한 번 끊긴 단어는 망이
+       돌아와도 '이미지 있음' 필터에서 계속 빠졌다(ttsConfig.checkAudioExists 와 같게). 있음(2xx)·없음(4xx)만 담는다. */
     const p = fetch(url, { method: 'HEAD', signal: AbortSignal.timeout(8000) })
-        .then(res => res.ok)
-        .catch(() => false)
+        .then(res => (res.status >= 500 ? null : res.ok), () => null)
         .then(ok => {
+        inflight.delete(k);
+        if (ok === null)
+            return false;
         map[k] = ok;
         scheduleSave();
-        inflight.delete(k);
         return ok;
     });
     inflight.set(k, p);

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

@@ -147,6 +147,13 @@ export function toStandardPronunciation(word) {
             cur.jong = cur.jong === JONG_NH ? JONG_N : cur.jong === JONG_RH ? JONG_R : JONG_NONE;
             continue;
         }
+        // 받침 ㅎ 계열 + 초성 ㅅ — ㅎ 은 떨어지고 ㅅ 은 된소리(표준발음법 제12항 2: 닿소 → 다쏘, 많소 → 만쏘, 싫소 → 실쏘).
+        // 전에는 이 갈래가 없어 끝소리 규칙으로 ㅎ 이 ㄷ 이 되어 '놓소 → 녿쏘' 가 나왔다.
+        if ((cur.jong === JONG_H || cur.jong === JONG_NH || cur.jong === JONG_RH) && next.cho === CHO_S) {
+            next.cho = CHO_SS;
+            cur.jong = cur.jong === JONG_NH ? JONG_N : cur.jong === JONG_RH ? JONG_R : JONG_NONE;
+            continue;
+        }
         // 받침 ㄱㄷㅂㅈ 계열 + 초성 ㅎ (먹히다 → 머키다, 앉히다 → 안치다, 읽히다 → 일키다)
         if (next.cho === CHO_H) {
             if (cur.jong === JONG_NJ) {

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

@@ -22,6 +22,10 @@ export function pressable(onPress, 옵션) {
         tabIndex: 0,
         ...(옵션?.selected === undefined ? {} : { 'aria-selected': 옵션.selected }),
         onKeyDown: (e) => {
+            /* **이 자리 자신에서 난 키만** 받는다. 안에 든 진짜 단추(랜딩 띠의 action 등)에서 누른 Enter 가 올라오면
+               전에는 여기서 preventDefault 해 그 단추의 click 을 막고 이 자리의 onPress 를 대신 불렀다. */
+            if (e.target !== e.currentTarget)
+                return;
             if (e.key !== 'Enter' && e.key !== ' ')
                 return;
             /* Space 는 그냥 두면 화면이 굴러간다 — 누름으로 바꾼다 */

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

@@ -56,11 +56,12 @@ export function duplicateTable(id) {
     const original = tables.find(t => t.id === id);
     if (!original)
         return null;
+    /* 사본도 설명·검색 구성·묶음을 가진다 — 전에는 items 만 옮겨, 사본을 '수정' 하면 검색 패널이 복원되지 않았다. */
     const copy = {
+        ...original,
         id: `${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
         name: `${original.name} (복사)`,
         savedAt: new Date().toISOString(),
-        items: original.items,
     };
     try {
         localStorage.setItem(STORAGE_KEY, JSON.stringify([copy, ...tables]));

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

@@ -49,3 +49,10 @@ export declare function buildUsablePool(opts: GenOptions): Promise<Array<{
     word: MvpWord;
     usable: string[];
 }>>;
+/**
+ * 정답(문제) 단어 거르개 — **난이도 등급 · 단어 구성(초성/중성/종성/받침없음 · 음절 수)**.
+ * buildUsablePool 이 후보에 거는 것과 같은 규칙이다(글자입력=철자, 발음입력=표준발음으로 본다).
+ * 실단어를 직접 고르는 생성기(음소 합성·받침/자음 탈락·음절 바꾸기)가 이것을 안 걸어, 설정한 필터와 무관한
+ * 문제를 냈다(초성 ㄱ·1등급인데 '카·라·파…'). 거를 것이 없으면 null.
+ */
+export declare function answerWordFilter(opts: GenOptions): ((w: MvpWord) => boolean) | null;

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

@@ -216,6 +216,36 @@ function _positionalPredicate(composition) {
 }
 // 대립(오답) 엔진은 공용 모듈 wordContrast.ts 로 분리 — hasStructureContrast, buildMultiPartPosContrast,
 // minimalPairDistractors 등은 거기서 import 한다(런타임과 훈련/단어표 만들기가 공유).
+/**
+ * 정답(문제) 단어 거르개 — **난이도 등급 · 단어 구성(초성/중성/종성/받침없음 · 음절 수)**.
+ * buildUsablePool 이 후보에 거는 것과 같은 규칙이다(글자입력=철자, 발음입력=표준발음으로 본다).
+ * 실단어를 직접 고르는 생성기(음소 합성·받침/자음 탈락·음절 바꾸기)가 이것을 안 걸어, 설정한 필터와 무관한
+ * 문제를 냈다(초성 ㄱ·1등급인데 '카·라·파…'). 거를 것이 없으면 null.
+ */
+export function answerWordFilter(opts) {
+    const gradeSet = opts.grade && opts.grade.length > 0 ? new Set(opts.grade) : null;
+    const composition = opts.composition ?? null;
+    const syllableSet = composition?.syllable != null
+        ? new Set(Array.isArray(composition.syllable) ? composition.syllable : [composition.syllable])
+        : null;
+    const preds = composition
+        ? [
+            _positionalPredicate(composition),
+            syllableSet ? (word) => syllableSet.has(syllableLength(word)) : null,
+        ].filter((p) => p != null)
+        : [];
+    if (!gradeSet && preds.length === 0)
+        return null;
+    const pron = opts.phonemeView === 'pron';
+    return (w) => {
+        if (gradeSet && (!w.grade || !gradeSet.has(w.grade)))
+            return false;
+        if (preds.length === 0)
+            return true;
+        const target = pron ? pronOfWord(w.w) : w.w;
+        return preds.every(pred => pred(target));
+    };
+}
 async function _buildUsablePool(opts) {
     const { difficulty = null, choseong = null, composition = null, targetSyllable = null, excludeNoImage = false } = opts;
     // 난이도 등급('1'~'4') 필터 — 정답(후보) 단어에만 적용(구성 필터와 동일 원칙, 오답 풀은 무관)

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

@@ -9,7 +9,7 @@ export declare function generateRuntimeItems(typeKey: WordTrainingTypeKey, opts?
  * 공통 조합을 백그라운드에서 사전 계산해 결과 캐시를 미리 채운다.
  * 이후 동일 조합으로 generateRuntimeItems 호출 시 즉시(<5ms) 반환.
  * fire-and-forget — 완료 여부에 관계없이 UI 블로킹 없음.
- * UI가 실제로 쓰는 difficulty(cap.difficulty→'count', 그 외 null)만 예열한다.
+ * UI가 실제로 쓰는 열쇠(count 5 · 난이도 'random'/'count' · 필터 기본값)로 예열한다.
  * (과거 대립종류 cho/jung/jong 예열은 UI 미사용이고 정작 count는 누락돼 첫 생성이 느렸음)
  */
 export declare function precomputeCommonCombinations(excludeNoImage: boolean): Promise<void>;

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

@@ -17,7 +17,7 @@ export { CAPABILITY, cardGroupOf, isValidQuestionWord, hasQuestionWordConstraint
 import { CAPABILITY, QUESTION_WORD_RULE } from './wordTrainingRuntimeTypes';
 import { buildDropContrastProblem, buildDropContrast3Problem, buildDropCompoundProblem, buildDropFinalConsonantProblem, buildRemoveConsonantProblem, buildChangeWholeSyllableProblem, buildSyllableMaskIndex } from './wordTrainingGenerators';
 /* 재료 고르기(풀 추리기·캐시·오답 샘플링)는 wordTrainingPool 로 갈라 두었다. */
-import { MVP, buildUsablePool, filterByCachedImage, getPronMap, nextId, pickOne, sample, sampleDistinctPron, _poolCacheKey, _EMPTY_SET, } from './wordTrainingPool';
+import { MVP, buildUsablePool, filterByCachedImage, getPronMap, nextId, pickOne, sample, sampleDistinctPron, _poolCacheKey, _EMPTY_SET, answerWordFilter, } from './wordTrainingPool';
 // ────────────────────────────────────────────────────────────────────────────
 // 카테고리별 generator
 // ────────────────────────────────────────────────────────────────────────────
@@ -100,11 +100,17 @@ async function genIncluded(opts) {
 async function genSameOrDiff(opts) {
     const { count = 10 } = opts;
     const pool = (await buildUsablePool(opts)).filter(e => e.usable.length >= 1);
-    return Array.from({ length: count }, (_, i) => {
-        const entry = pickOne(pool);
-        if (!entry)
-            return null;
-        const isSame = i % 2 === 0;
+    if (!pool.length)
+        return [];
+    /* 같음·다름을 **절반씩 섞어** 둔다. 전에는 i % 2 로 정해 늘 같음·다름·같음… 순서라 듣지 않고도 답을 맞힐 수
+       있었고, 단어를 복원추출(pickOne)해 풀이 작지 않아도 같은 단어가 여러 문항에 나왔다. 풀이 문항 수보다 크면
+       겹치지 않게 뽑는다. */
+    const entries = pool.length >= count
+        ? sample(pool, count)
+        : shuffle(Array.from({ length: count }, (_, i) => pool[i % pool.length]));
+    const sameFlags = shuffle(Array.from({ length: count }, (_, i) => i < Math.ceil(count / 2)));
+    return entries.map((entry, i) => {
+        const isSame = sameFlags[i];
         let pair;
         if (isSame)
             pair = [entry.word.w, entry.word.w];
@@ -119,7 +125,7 @@ async function genSameOrDiff(opts) {
             pair,
             same: isSame,
         };
-    }).filter((x) => Boolean(x));
+    });
 }
 /**
  * STARTS_WITH_SAME_SOUND
@@ -260,10 +266,14 @@ async function genChangeWholeSyll(N, opts, idPrefix) {
     const maskIndex = buildSyllableMaskIndex(wordSet);
     const phonemeView = opts.phonemeView ?? 'char';
     const comp = opts.composition ?? null;
+    // 등급은 정답(문제) 단어에만 건다 — 오답 탐색 풀(maskIndex)은 그대로(buildUsablePool 과 같은 원칙). 전에는 등급이 빠졌다.
+    const answerOk = answerWordFilter({ grade: opts.grade });
     const out = [];
     for (const w of shuffle(words)) {
         if (out.length >= count)
             break;
+        if (answerOk && !answerOk(w))
+            continue;
         const prob = buildChangeWholeSyllableProblem(w.w, comp, pronMap, phonemeView, maskIndex, null, null);
         if (!prob)
             continue;
@@ -449,13 +459,17 @@ async function genListenAndRememberOrder(opts) {
 // 음소 단위(합성/탈락) — 실단어 데이터 기반. 이미지 필터 적용.
 // ────────────────────────────────────────────────────────────────────────────
 /** N음절 실단어(이미지 필터 적용) 중 조건(pred: 첫 음절 분해값 기준)을 만족하는 것 */
-function realWordsOfLen(N, excludeNoImage, pred) {
+function realWordsOfLen(N, opts, pred) {
     const all = MVP.filter(w => w.w && w.s === N);
-    const ok = excludeNoImage ? filterByCachedImage(all.map(w => w.w)) : null;
+    const ok = opts.excludeNoImage ? filterByCachedImage(all.map(w => w.w)) : null;
+    // 설정한 등급·단어 구성도 건다 — 전에는 음절 수·이미지만 봐서 필터와 무관한 문제가 나왔다
+    const answerOk = answerWordFilter(opts);
     const out = [];
     for (const mw of all) {
         if (ok && !ok.has(mw.w))
             continue;
+        if (answerOk && !answerOk(mw))
+            continue;
         if (pred) {
             const s = parseSyllable(mw.w);
             if (!s || !pred(s))
@@ -467,7 +481,7 @@ function realWordsOfLen(N, excludeNoImage, pred) {
 }
 /** MERGE_2_PHONEMES — 초성+모음 합쳐 1음절(받침 없음). 실단어 데이터 기반 */
 function genMerge2Phonemes(opts) {
-    const pool = realWordsOfLen(1, opts.excludeNoImage ?? false, s => s.jong === 0);
+    const pool = realWordsOfLen(1, opts, s => s.jong === 0);
     return sample(pool, opts.count ?? 10).map((e, i) => {
         const s = parseSyllable(e.w);
         return { id: nextId('M2P-item'), index: i + 1, parts: [CHOSEONG[s.cho], JUNGSEONG[s.jung]], answer: e.w, word: e.w };
@@ -476,7 +490,7 @@ function genMerge2Phonemes(opts) {
 /** MERGE_3_PHONEMES — 초성+모음+종성 합쳐 1음절(홑받침). 실단어 데이터 기반 */
 function genMerge3Phonemes(opts) {
     // 홑받침만(겹받침은 음소 2개라 '3음소'가 아니게 됨)
-    const pool = realWordsOfLen(1, opts.excludeNoImage ?? false, s => s.jong > 0 && !JONG_DECOMPOSE[s.jong]);
+    const pool = realWordsOfLen(1, opts, s => s.jong > 0 && !JONG_DECOMPOSE[s.jong]);
     return sample(pool, opts.count ?? 10).map((e, i) => {
         const s = parseSyllable(e.w);
         return { id: nextId('M3P-item'), index: i + 1, parts: [CHOSEONG[s.cho], JUNGSEONG[s.jung], JONGSEONG[s.jong]], answer: e.w, word: e.w };
@@ -486,7 +500,7 @@ function genMerge3Phonemes(opts) {
  *  풀 조건은 QUESTION_WORD_RULE와 공유 — 편집기 무작위 선택/검증이 이 규칙을 그대로 쓴다. */
 function genDropFinalConsonant(opts) {
     const rule = QUESTION_WORD_RULE.DROP_FINAL_CONSONANT_FROM_1SYLL;
-    const pool = realWordsOfLen(rule.syllables, opts.excludeNoImage ?? false, rule.syllable);
+    const pool = realWordsOfLen(rule.syllables, opts, rule.syllable);
     const pronMap = getPronMap();
     const out = [];
     for (const e of shuffle(pool)) {
@@ -506,7 +520,7 @@ function genDropFinalConsonant(opts) {
 function genRemoveConsonant(opts) {
     // 받침 없는 자음 초성 1음절만 → 자음을 빼면 순수 모음 음절(ㅇ+모음)이 남는다.
     const rule = QUESTION_WORD_RULE.REMOVE_CONSONANT_AND_IDENTIFY_PHONEME;
-    const pool = realWordsOfLen(rule.syllables, opts.excludeNoImage ?? false, rule.syllable);
+    const pool = realWordsOfLen(rule.syllables, opts, rule.syllable);
     const pronMap = getPronMap();
     const out = [];
     for (const e of shuffle(pool)) {
@@ -585,11 +599,14 @@ async function _generateRuntimeItems(typeKey, opts = {}) {
  * 공통 조합을 백그라운드에서 사전 계산해 결과 캐시를 미리 채운다.
  * 이후 동일 조합으로 generateRuntimeItems 호출 시 즉시(<5ms) 반환.
  * fire-and-forget — 완료 여부에 관계없이 UI 블로킹 없음.
- * UI가 실제로 쓰는 difficulty(cap.difficulty→'count', 그 외 null)만 예열한다.
+ * UI가 실제로 쓰는 열쇠(count 5 · 난이도 'random'/'count' · 필터 기본값)로 예열한다.
  * (과거 대립종류 cho/jung/jong 예열은 UI 미사용이고 정작 count는 누락돼 첫 생성이 느렸음)
  */
 export async function precomputeCommonCombinations(excludeNoImage) {
-    const difficulties = [null, 'count'];
+    /* **화면이 실제로 부르는 열쇠와 똑같이** 예열한다. 전에는 count:10 · 난이도 null/'count' 로 돌았는데 화면
+       (useWordTrainingDataGeneration)은 count:5 · 필터 기본 난이도 'random'(음소를 고르면 'count')으로 불러 캐시 열쇠가
+       달랐다 — 예열 계산을 전부 버리고 첫 생성이 다시 계산했다. */
+    const difficulties = ['random', 'count'];
     const types = Object.keys(CAPABILITY);
     let tick = 0;
     for (const diff of difficulties) {
@@ -597,9 +614,13 @@ export async function precomputeCommonCombinations(excludeNoImage) {
             const cap = CAPABILITY[t];
             generateRuntimeItems(t, {
                 difficulty: cap.difficulty ? diff : null,
-                choseong: null,
-                count: 10,
+                contrastCount: 1,
+                composition: null,
+                count: 5,
                 excludeNoImage,
+                sameStructureOnly: true,
+                phonemeView: 'char',
+                grade: null,
             }).catch(() => { });
             // 6 타입마다 마이크로태스크 양보 → 메인 스레드 프레임 블로킹 방지
             if (++tick % 6 === 0)

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

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

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

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