@ihabdevteam/core 0.145.0 → 0.147.0

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

@@ -45,6 +45,8 @@ export function useDailyTrainingSelection(userId) {
     }, []);
     useEffect(() => {
         let cancelled = false;
+        let 떠남 = false;
+        let 적용됨 = false;
         let timer;
         let attempts = 0;
         const MAX_ATTEMPTS = 40; // 250ms * 40 = 10초 후 폴링 중단(풀이 영영 비는 경우 무한루프 방지)
@@ -60,6 +62,9 @@ export function useDailyTrainingSelection(userId) {
         }
         catch { }
         const apply = (sel) => {
+            if (떠남)
+                return;
+            적용됨 = true;
             todayRef.current = sel.today;
             yesterdayRef.current = sel.yesterday;
             setLoaded(true);
@@ -79,13 +84,16 @@ export function useDailyTrainingSelection(userId) {
                     return;
                 }
             }
-            // 캐시 miss → 데이터 로드 후 새 선택
-            try {
-                await ensureTrainingDataLoaded(3000);
+            /* 캐시 miss → 데이터 로드 후 새 선택. 로드는 **2초마다 한 번만** 다시 청한다 — 250ms 마다 부르면 받기가 곧바로 실패하는
+               배포(형식 오류)에서 10초에 850KB 자료를 40번 받았다. 그 사이 폴링은 선택만 다시 계산한다. */
+            if (attempts % 8 === 0) {
+                try {
+                    await ensureTrainingDataLoaded(3000);
+                }
+                catch { }
+                if (cancelled)
+                    return;
             }
-            catch { }
-            if (cancelled)
-                return;
             const sel = resolveSelection(forceRefresh, undefined, userId);
             if (hasItems(sel.today)) {
                 apply(sel);
@@ -101,9 +109,29 @@ export function useDailyTrainingSelection(userId) {
                 stop();
             }
         };
+        /* 포기한 뒤(10초)라도 자료가 도착하면 다시 계산한다 — 느린 회선에서 13초 걸려 받은 회원은 새로고침 전까지 "자료를 못 찾음" 에 남았다 */
+        const 자료도착 = () => {
+            if (떠남 || 적용됨)
+                return;
+            const sel = resolveSelection(forceRefresh, undefined, userId);
+            if (hasItems(sel.today))
+                apply(sel);
+        };
+        try {
+            window.addEventListener('speechear.data.updated', 자료도착);
+        }
+        catch { }
         tryFill();
         timer = setInterval(tryFill, 250);
-        return () => { cancelled = true; stop(); };
+        return () => {
+            cancelled = true;
+            떠남 = true;
+            stop();
+            try {
+                window.removeEventListener('speechear.data.updated', 자료도착);
+            }
+            catch { }
+        };
         // 오늘 은 날짜가 바뀌었다는 신호 — resolveSelection 이 안에서 오늘 날짜를 읽는다
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [userId, 오늘]);

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

@@ -46,9 +46,10 @@ export function useTablePaging(rows, resetOn, opts) {
     const total = Math.max(1, Math.ceil(rows.length / Number(pageSize)));
     /* 행이 줄어 범위를 넘으면 **상태도** 끝 쪽으로 맞춘다 — 보이는 쪽만 조이고 상태를 두면, 필터로 줄었다가 다시 늘 때 예전
        5쪽으로 튀었다. 렌더 중에 맞춘다(위 resetOn 과 같은 꼴). */
-    if (page > total)
-        setPage(total);
-    const 이쪽 = Math.min(page, total);
+    // 1 보다 작은 쪽(setPage(0)·-1)도 막는다 — 0 은 빈 쪽, -1 은 음수 slice 로 엉뚱한 줄이 나왔다
+    if (page > total || page < 1 || !Number.isFinite(page))
+        setPage(Math.min(Math.max(1, Number.isFinite(page) ? page : 1), total));
+    const 이쪽 = Math.min(Math.max(1, Number.isFinite(page) ? page : 1), total);
     const pageRows = useMemo(() => rows.slice((이쪽 - 1) * Number(pageSize), 이쪽 * Number(pageSize)), [rows, 이쪽, pageSize]);
     return {
         pageRows,

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

@@ -1,6 +1,9 @@
 /**
- * 훈련 팝업 마운트~언마운트 시간을 기록합니다.
- * 5초 미만 세션(잘못 열었다 닫은 경우)은 무시합니다.
+ * 훈련 팝업을 **보고 있던** 시간을 기록합니다.
+ * 보인 시간이 5초 미만(잘못 열었다 닫은 경우)이면 무시합니다.
+ *
+ * 한 팝업에 **한 줄** 만 보냅니다 — 떠날 때, 또는 페이지가 내려갈 때(pagehide: 팝업을 연 채 탭·앱을 닫음). 화면이 가려진
+ * 동안(탭 전환·앱 백그라운드)의 시간은 빼고 모읍니다 — 전에는 연 채 3시간 잠가 둔 시간이 훈련 시간으로 적혔다.
  *
  * @public
  */

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

@@ -2,8 +2,11 @@
 import { useEffect } from 'react';
 import { logTrainingTime } from '../utils/trainingLogger';
 /**
- * 훈련 팝업 마운트~언마운트 시간을 기록합니다.
- * 5초 미만 세션(잘못 열었다 닫은 경우)은 무시합니다.
+ * 훈련 팝업을 **보고 있던** 시간을 기록합니다.
+ * 보인 시간이 5초 미만(잘못 열었다 닫은 경우)이면 무시합니다.
+ *
+ * 한 팝업에 **한 줄** 만 보냅니다 — 떠날 때, 또는 페이지가 내려갈 때(pagehide: 팝업을 연 채 탭·앱을 닫음). 화면이 가려진
+ * 동안(탭 전환·앱 백그라운드)의 시간은 빼고 모읍니다 — 전에는 연 채 3시간 잠가 둔 시간이 훈련 시간으로 적혔다.
  *
  * @public
  */
@@ -11,16 +14,50 @@ export default function useTrainingSessionLog(trainingType) {
     useEffect(() => {
         if (!trainingType)
             return; // 타입 미상이면 기록하지 않음
-        const startedAt = new Date();
-        return () => {
-            const endedAt = new Date();
-            if (endedAt.getTime() - startedAt.getTime() < 5000)
+        /* **한 팝업 = 한 줄.** 보이는 구간마다 따로 보내면 서버가 줄 수를 세션 수로 세어(v_user_training_time_stats) 탭을 오갈 때마다
+           문장 훈련 횟수가 늘었다. 보이던 시간만 모아 두었다가 떠날 때(또는 페이지가 내려갈 때) 한 번 보낸다 — 끝 시각은 처음 보인 때 + 보인 시간. */
+        const 보임 = () => typeof document === 'undefined' || document.visibilityState !== 'hidden';
+        let 처음보임 = null;
+        let 구간시작 = null;
+        let 모은ms = 0;
+        let 보냄 = false;
+        const 구간열기 = () => { const t = Date.now(); if (처음보임 == null)
+            처음보임 = t; if (구간시작 == null)
+            구간시작 = t; };
+        const 구간닫기 = () => { if (구간시작 != null) {
+            모은ms += Date.now() - 구간시작;
+            구간시작 = null;
+        } };
+        if (보임())
+            구간열기();
+        const 보내기 = () => {
+            if (보냄)
+                return;
+            구간닫기();
+            if (처음보임 == null || 모은ms < 5000)
                 return;
+            보냄 = true;
             logTrainingTime({
                 trainingType,
-                startedAt: startedAt.toISOString(),
-                endedAt: endedAt.toISOString(),
+                startedAt: new Date(처음보임).toISOString(),
+                endedAt: new Date(처음보임 + 모은ms).toISOString(),
             });
         };
+        const 보임바뀜 = () => { if (보임())
+            구간열기();
+        else
+            구간닫기(); };
+        if (typeof document !== 'undefined')
+            document.addEventListener('visibilitychange', 보임바뀜);
+        // 페이지가 내려가면(탭·앱 닫기) React 정리가 안 돈다 — 그때 보낸다
+        if (typeof window !== 'undefined')
+            window.addEventListener('pagehide', 보내기);
+        return () => {
+            if (typeof document !== 'undefined')
+                document.removeEventListener('visibilitychange', 보임바뀜);
+            if (typeof window !== 'undefined')
+                window.removeEventListener('pagehide', 보내기);
+            보내기();
+        };
     }, [trainingType]);
 }

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

@@ -26,6 +26,10 @@ const memCache = new Map();
 /* 받아 봤는데 뜻이 없던 열쇠 — 다시 묻지 않는다. 전에는 뜻 없는 낱말이 캐시에 안 남아 표를 다시 정렬하거나 쪽을
    넘길 때마다 같은 낱말을 또 조회했다. (조회가 실패한 것은 여기 넣지 않는다 — 다음에 다시 받는다.) */
 const noMeaning = new Set();
+/* 빈 응답(한 줄도 못 받음)으로 '뜻 없음' 이 된 열쇠와 그 때 — 조회 함수는 실패도 빈 배열로 돌려주므로 영영 굳히지 않고, 사용자 추가
+   낱말처럼 정말 뜻이 없는 쪽을 오갈 때마다 다시 묻지도 않게 **잠시만**(1분) 묻지 않는다. */
+const 빈응답때 = new Map();
+const 빈응답유예ms = 60_000;
 export function useWordMeanings(rows, fetchMeanings) {
     /* 캐시는 모듈 스코프 Map 이라 갱신이 렌더에 자동 반영되지 않는다 — 조회가 끝나면 이 값을
        올려 아래 스냅샷을 다시 계산시킨다(캐시 히트만으로 리렌더가 연쇄되지 않도록 분리). */
@@ -35,7 +39,8 @@ export function useWordMeanings(rows, fetchMeanings) {
     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) && !noMeaning.has(k));
+        const 지금 = Date.now();
+        const missing = wanted.filter(k => !memCache.has(k) && !noMeaning.has(k) && !(지금 - (빈응답때.get(k) ?? -Infinity) < 빈응답유예ms));
         if (missing.length === 0)
             return; // 전부 캐시에 있음 — 네트워크·상태 갱신 불필요
         let cancelled = false;
@@ -50,9 +55,15 @@ export function useWordMeanings(rows, fetchMeanings) {
             /* 한 줄도 못 받았으면 '뜻 없음' 으로 굳히지 않는다 — 조회 함수는 실패를 빈 배열로 돌려주는 약속이라, 잠깐 끊긴 망이
                그 쪽 낱말들을 새로고침 전까지 '뜻 없음' 으로 묶었다. 받은 게 있으면 그 응답에 빠진 낱말만 없는 것으로 본다. */
             if (got.length > 0)
-                for (const k of missing)
+                for (const k of missing) {
                     if (!memCache.has(k))
                         noMeaning.add(k);
+                }
+            else {
+                const t = Date.now();
+                for (const k of missing)
+                    빈응답때.set(k, t);
+            }
             if (cancelled || got.length === 0)
                 return;
             setFetched(v => v + 1);

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

@@ -56,7 +56,11 @@ export declare function getTrainingPools(): Record<string, unknown[]>;
 export declare function loadTrainingData(): Promise<void>;
 /** @public */
 export declare function isTrainingDataLoaded(): boolean;
-export declare function ensureTrainingDataLoaded(timeout?: number): Promise<unknown>;
+/**
+ * 자료를 받게 하고 **받았는지** 를 돌려준다(시간 초과·실패는 false). 전에는 성공·3초 초과·실패가 모두 undefined 로 끝나
+ * 부르는 쪽이 빈 풀로 계획을 만들고도 알 길이 없었다. 늦게 도착하면 'speechear.data.updated' 가 온다.
+ */
+export declare function ensureTrainingDataLoaded(timeout?: number): Promise<boolean>;
 declare const _default: {
     NOISE_DATAS: unknown[];
     SHORT_STORIES: unknown[];

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

@@ -111,6 +111,9 @@ export async function loadTrainingData() {
             for (const key of Object.keys(map || {})) {
                 const groups = map[key] || [];
                 for (const g of groups) {
+                    // 한 행이 null·글자면 건너뛴다 — 그 한 행의 TypeError 로 자료 전체를 버리고 매번 같은 실패를 되풀이했다
+                    if (!g || typeof g !== 'object')
+                        continue;
                     const gr = g;
                     const t = String(gr.training_type || key);
                     const cat0 = String(gr.category_main_code || gr.category_main || gr.category_0 || '');
@@ -149,22 +152,35 @@ export async function loadTrainingData() {
         SHORT_STORIES.push(...받음.short);
         LONG_STORIES.push(...받음.long);
         ORDER_SETS.push(...받음.order);
+        // 다 채운 뒤 _loaded 를 먼저 세운다 — 'updated' 를 받은 쪽이 isTrainingDataLoaded() 로 확인하면 아직 false 였다
+        _loaded = true;
         try {
-            window.dispatchEvent(new Event('speechear.data.updated'));
+            computeDailySelection();
         }
         catch (e) { }
         try {
-            computeDailySelection();
+            window.dispatchEvent(new Event('speechear.data.updated'));
         }
         catch (e) { }
-        _loaded = true;
     })();
     return _loading;
 }
 /** @public */
 export function isTrainingDataLoaded() { return _loaded; }
+/**
+ * 자료를 받게 하고 **받았는지** 를 돌려준다(시간 초과·실패는 false). 전에는 성공·3초 초과·실패가 모두 undefined 로 끝나
+ * 부르는 쪽이 빈 풀로 계획을 만들고도 알 길이 없었다. 늦게 도착하면 'speechear.data.updated' 가 온다.
+ */
 export async function ensureTrainingDataLoaded(timeout = 3000) {
     const p = loadTrainingData();
-    return Promise.race([p, new Promise((res) => setTimeout(res, timeout))]);
+    let t;
+    try {
+        await Promise.race([p, new Promise((res) => { t = setTimeout(res, timeout); })]);
+    }
+    finally {
+        if (t !== undefined)
+            clearTimeout(t);
+    }
+    return _loaded;
 }
 export default { NOISE_DATAS, SHORT_STORIES, LONG_STORIES, ORDER_SETS, loadTrainingData, ensureTrainingDataLoaded };

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

@@ -58,4 +58,4 @@ export interface PlanLimits {
 /** @public 요금제 티어별 제한 (표시되지 않는 레거시 티어는 생략) */
 export declare const PLAN_LIMITS: Partial<Record<PlanTier, PlanLimits>>;
 /** product code → 요금제 티어 */
-export declare function getPlanTier(productCode: string): PlanTier;
+export declare function getPlanTier(productCode: string | null | undefined): PlanTier;

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

@@ -145,7 +145,13 @@ export const PLAN_LIMITS = {
 };
 /** product code → 요금제 티어 */
 export function getPlanTier(productCode) {
-    const c = productCode.toLowerCase();
+    const c = (productCode ?? '').toLowerCase();
+    /* 무료 코드는 접두사 규칙보다 먼저 — 'speechear_free' 가 아래 speechear_ 규칙에 걸려 유료 개인 스탠다드로 올라갔고,
+       'manager_free' 는 규칙이 없어 none 이었다(어드민 요금제 PLANS 의 plan_id). null 코드는 던지지 않고 none. */
+    if (c === 'speechear_free' || c === 'free')
+        return 'free';
+    if (c.startsWith('manager_free') || c.startsWith('mgr_free'))
+        return 'mgr_free';
     if (c.startsWith('manager_enterprise'))
         return 'enterprise';
     if (c.startsWith('manager_pro'))

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

@@ -1,13 +1,13 @@
 /** 글자 둘을 한국어 차례로 견준다 */
 export declare function 한글순(a: string, b: string): number;
 /**
- * 표의 한 칸끼리 견준다 — **숫자는 숫자로, 나머지는 글자 속 숫자까지 수로.**
+ * 표의 한 칸끼리 견준다 — **숫자는 숫자로, 글자 속 숫자도 수로.**
  *
  * 표의 칸은 무엇이든 올 수 있어서 늘 글자로 견주면 **숫자 칸이 망가진다**
- * (`10` 이 `9` 앞에 선다). 그래서 둘 다 온전한 숫자(수, 또는 숫자만 든 글자)면 숫자로 견주고,
- * 그 밖에는 한국어 차례로 견주되 글자 안의 숫자는 수로 읽는다(`회차 9` 가 `회차 10` 앞).
+ * (`10` 이 `9` 앞에 선다). 값을 숫자 조각과 글자 조각으로 나눠 앞에서부터 견준다 —
+ * `회차 9` 가 `회차 10` 앞, `12.25%` 가 `12.5%` 앞, `-10 dB` 가 `-5 dB` 앞. 숫자 조각은 글자 조각 앞에 선다.
  *
- * 비어 있는 값(`null`·`undefined`)은 빈 글자로 본다 — 부르는 쪽이 이미
+ * 비어 있는 값(`null`·`undefined`·NaN)은 빈 글자로 본다 — 부르는 쪽이 이미
  * `?? ''` 로 채워 넘기던 것과 같은 뜻이다.
  */
 export declare function 칸순(a: unknown, b: unknown): number;

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

@@ -22,39 +22,69 @@ const 콜레이터 = (() => {
 export function 한글순(a, b) {
     return 콜레이터().compare(a, b);
 }
-const 숫자글자 = /^-?\d+(\.\d+)?$/;
-/* 칸의 글자 비교는 **안의 숫자도 수로** 본다 — 숫자 칸끼리는 수로, 섞인 칸은 글자로 견주면 '9'<'10'(수)·'10'<'10분'(글자)·
-   '10분'<'9'(글자) 로 돌고 돌아, 같은 행을 들어온 차례만 바꿔도 정렬 결과가 달랐다. 수를 수로 읽는 콜레이터는
-   숫자끼리의 차례와 같은 쪽을 낸다. */
-const 칸콜레이터 = (() => {
-    let 것 = null;
-    return () => {
-        if (!것)
-            것 = new Intl.Collator('ko', { numeric: true });
-        return 것;
-    };
-})();
+const 조각열쇠 = new Map();
+function 조각내기(s) {
+    const 있음 = 조각열쇠.get(s);
+    if (있음)
+        return 있음;
+    const out = [];
+    // 뒤돌아보기(?<=) 는 iOS 15 Safari 가 못 읽어 모듈째 깨지므로 쓰지 않는다 — 빼기표 앞 글자를 손으로 본다
+    const re = /-?\d+(?:\.\d+)?/g;
+    let 끝 = 0;
+    for (let m = re.exec(s); m; m = re.exec(s)) {
+        let 시작 = m.index;
+        let 수 = m[0];
+        if (수[0] === '-' && 시작 > 0 && !/\s/.test(s[시작 - 1])) {
+            시작 += 1;
+            수 = 수.slice(1);
+        }
+        if (시작 > 끝)
+            out.push(s.slice(끝, 시작));
+        out.push(Number(수));
+        끝 = m.index + m[0].length;
+    }
+    if (끝 < s.length)
+        out.push(s.slice(끝));
+    if (조각열쇠.size > 5000)
+        조각열쇠.clear();
+    조각열쇠.set(s, out);
+    return out;
+}
 /**
- * 표의 한 칸끼리 견준다 — **숫자는 숫자로, 나머지는 글자 속 숫자까지 수로.**
+ * 표의 한 칸끼리 견준다 — **숫자는 숫자로, 글자 속 숫자도 수로.**
  *
  * 표의 칸은 무엇이든 올 수 있어서 늘 글자로 견주면 **숫자 칸이 망가진다**
- * (`10` 이 `9` 앞에 선다). 그래서 둘 다 온전한 숫자(수, 또는 숫자만 든 글자)면 숫자로 견주고,
- * 그 밖에는 한국어 차례로 견주되 글자 안의 숫자는 수로 읽는다(`회차 9` 가 `회차 10` 앞).
+ * (`10` 이 `9` 앞에 선다). 값을 숫자 조각과 글자 조각으로 나눠 앞에서부터 견준다 —
+ * `회차 9` 가 `회차 10` 앞, `12.25%` 가 `12.5%` 앞, `-10 dB` 가 `-5 dB` 앞. 숫자 조각은 글자 조각 앞에 선다.
  *
- * 비어 있는 값(`null`·`undefined`)은 빈 글자로 본다 — 부르는 쪽이 이미
+ * 비어 있는 값(`null`·`undefined`·NaN)은 빈 글자로 본다 — 부르는 쪽이 이미
  * `?? ''` 로 채워 넘기던 것과 같은 뜻이다.
  */
 export function 칸순(a, b) {
-    /* NaN 은 숫자가 아닌 것으로 — a - b 가 NaN 이면 정렬 비교가 어긋나 줄이 뒤섞였다. 글자로 온 숫자('10'·'9')도
-       둘 다 온전한 숫자면 숫자로 견준다(전에는 '10' 이 '9' 앞에 섰다). */
-    const 수 = (v) => (typeof v === 'number' && !Number.isNaN(v) ? v : typeof v === 'string' && 숫자글자.test(v.trim()) ? Number(v) : null);
-    const na = 수(a), nb = 수(b);
-    if (na !== null && nb !== null)
-        return na - nb;
-    const sa = a == null ? '' : String(a), sb = b == null ? '' : String(b);
-    /* 소수점·음수가 든 글자('12.5%'·'-10 dB')는 수로 읽는 콜레이터가 틀린다 — 점 뒤를 따로 떼어 '12.5' 가 '12.25' 뒤에,
-       빼기표를 버려 '-5' 가 '-10' 뒤에 섰다. 그런 칸은 한국어 글자 차례로 둔다. 선행 0 도 수로 읽으면 'A007'='A7' 이 되어 글자로. */
-    if (/\d\.\d|-\d|(^|\D)0\d/.test(sa) || /\d\.\d|-\d|(^|\D)0\d/.test(sb))
-        return 한글순(sa, sb);
-    return 칸콜레이터().compare(sa, sb);
+    const 글 = (v) => (v == null || (typeof v === 'number' && Number.isNaN(v)) ? '' : String(v).trim());
+    const sa = 글(a), sb = 글(b);
+    if (sa === sb)
+        return 0;
+    /* 수(number)는 글로 바꿔 쪼개지 않고 **수 조각 하나** 로 — '1e+21'·'1e-7' 로 쪼개면 1e21 이 5 앞에, -Infinity 가 끝에 섰다 */
+    const 열쇠 = (v, s) => (typeof v === 'number' && !Number.isNaN(v) ? [v] : 조각내기(s));
+    const ka = 열쇠(a, sa), kb = 열쇠(b, sb);
+    const n = Math.min(ka.length, kb.length);
+    for (let i = 0; i < n; i++) {
+        const x = ka[i], y = kb[i];
+        if (typeof x === 'number' && typeof y === 'number') {
+            if (x !== y)
+                return x - y;
+            continue;
+        } // 같지 않은 ±Infinity 끼리도 부호가 맞다
+        if (typeof x === 'number')
+            return -1;
+        if (typeof y === 'number')
+            return 1;
+        const c = 한글순(x, y);
+        if (c !== 0)
+            return c;
+    }
+    if (ka.length !== kb.length)
+        return ka.length - kb.length;
+    return 한글순(sa, sb);
 }

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

@@ -55,7 +55,9 @@ export function toItemResults(raw) {
             /* 물음이 담긴 칸 이름이 유형마다 다르다 — 문장 훈련 넷(소음 하 듣기·문장 순서화·
                짧은/긴 이야기)은 `sentence` 에, 낱말 훈련은 `word` 에 담는다. `sentence` 를
                빠뜨렸더니 대면 세션 기록의 item_id 가 전부 null 이었다(2026-08-27 실측). */
-            question: text(r.question) ?? text(r.sentence) ?? text(r.word) ?? text(r.targetSyllable),
+            /* 단어 조작(합성·대치·탈락)·확인형은 물음을 `text` 에 담는다 — 빠져 기록의 question 이 null 이라 오답 패널에서 통째로
+               빠졌는데, 결과 창(resolveProblem)은 text 를 읽어 보여 두 화면이 어긋났다. 결과 창과 같은 칸들을 본다. */
+            question: text(r.question) ?? text(r.q) ?? text(r.sentence) ?? text(r.text) ?? text(r.prompt) ?? text(r.word) ?? text(r.targetSyllable),
             answer: text(r.answer),
             selected: text(r.selectedText) ?? text(r.selected),
             correct: itemCorrectness(r),

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

@@ -59,7 +59,7 @@ export declare function syllablePron(ch: string): string;
 export declare function soundOf(syll: string, pronMap: Map<string, string>): string;
 /** @public comp에서 실제로 선택된 파트 1개(초성 우선)를 반환. 없으면 null. */
 export declare function primarySelPart(comp: CompositionFilter | null): 'cho' | 'jung' | 'jong' | null;
-/** @public 음절(분해값 s)이 comp의 선택 파트들과 모두 일치하는지(=선택 음소를 가진 음절). */
+/** @public 음절(분해값 s)이 comp의 선택 파트들과 모두 일치하는지(=선택 음소를 가진 음절). `jongNone` 이면 받침 없는 음절만 맞고 `jong` 은 보지 않는다(풀 필터와 같게). */
 export declare function syllMatchesComp(s: Syllable, comp: CompositionFilter): boolean;
 /**
  * @public 발음 모드에서 comp 매칭에 쓸 음절 배열. 표준발음(pronMap)의 음절수가 철자와 같으면 발음 음절로,
@@ -75,6 +75,8 @@ export declare function syllableContrasts(cs: Syllable, part: 'cho' | 'jung' | '
 export interface TrainingProblem {
     question: string;
     distractors: string[];
+    /** 탈락 문제에서 빠진 조각(합성어 부분 탈락이 채운다 — 앞뒤로 같은 조각이 있으면 remain 만으로는 어느 쪽인지 모른다) */
+    dropped?: string;
 }
 /**
  * @public 2음절 단어 → [문제단어, 남는 1음절(정답), 대립쌍 오답 2]. 정답·오답 모두 '실단어'(wordSet)만 인정.
@@ -92,7 +94,7 @@ export declare function buildDropContrast3Problem(word: string, comp: Compositio
  * @public 합성어 부분 탈락 → [문제단어(합성어), 남는 실단어(정답), 그 단어의 대립쌍 실단어 오답 2].
  * 합성어 근사: 앞/뒤로 나눈 두 조각이 '둘 다 실단어'(wordSet)인 첫 조합을 채택(예: 손수건=손+수건).
  * 정답·오답 전부 실단어라 발음이 그대로. comp(훈련음소) 지정 시 남는 단어의 그 자리를 대립, 없으면 전 음절.
- * dropPos: 0=어두 어근(앞) 탈락, 1=어말 어근(뒤) 탈락. 편집기·런타임 공용.
+ * dropPos: 0=어두 어근(앞) 탈락, 1=어말 어근(뒤) 탈락. 결과의 `dropped` 에 뺀 조각을 담는다. 편집기·런타임 공용.
  */
 export declare function buildDropCompoundProblem(word: string, comp: CompositionFilter | null, pronMap: Map<string, string>, phonemeView: 'char' | 'pron', wordSet: Set<string>, dropPos?: number | null): TrainingProblem | null;
 /**

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

@@ -207,10 +207,13 @@ export function primarySelPart(comp) {
         return 'jong';
     return null;
 }
-/** @public 음절(분해값 s)이 comp의 선택 파트들과 모두 일치하는지(=선택 음소를 가진 음절). */
+/** @public 음절(분해값 s)이 comp의 선택 파트들과 모두 일치하는지(=선택 음소를 가진 음절). `jongNone` 이면 받침 없는 음절만 맞고 `jong` 은 보지 않는다(풀 필터와 같게). */
 export function syllMatchesComp(s, comp) {
     const ok = (arr, val) => !hasSel(arr) || asArr(arr).includes(val);
-    return ok(comp.cho, CHOSEONG[s.cho]) && ok(comp.jung, JUNGSEONG[s.jung]) && ok(comp.jong, JONGSEONG[s.jong]);
+    /* '받침 없음'(jongNone)도 본다 — 풀 필터(wordTrainingPool)는 jongNone 이면 받침 없는 음절만 맞다고 보는데 여기만 무시해, 초성 ㅎ +
+       받침 없음으로 골라도 음절 바꾸기가 '해협' 의 '협' 을 바꿀 음절로 골랐다. jongNone 이면 jong 선택은 보지 않는다(풀과 같게). */
+    const jongOk = comp.jongNone ? s.jong === 0 : ok(comp.jong, JONGSEONG[s.jong]);
+    return ok(comp.cho, CHOSEONG[s.cho]) && ok(comp.jung, JUNGSEONG[s.jung]) && jongOk;
 }
 /**
  * @public 발음 모드에서 comp 매칭에 쓸 음절 배열. 표준발음(pronMap)의 음절수가 철자와 같으면 발음 음절로,
@@ -364,7 +367,7 @@ export function buildDropContrast3Problem(word, comp, pronMap, phonemeView, word
  * @public 합성어 부분 탈락 → [문제단어(합성어), 남는 실단어(정답), 그 단어의 대립쌍 실단어 오답 2].
  * 합성어 근사: 앞/뒤로 나눈 두 조각이 '둘 다 실단어'(wordSet)인 첫 조합을 채택(예: 손수건=손+수건).
  * 정답·오답 전부 실단어라 발음이 그대로. comp(훈련음소) 지정 시 남는 단어의 그 자리를 대립, 없으면 전 음절.
- * dropPos: 0=어두 어근(앞) 탈락, 1=어말 어근(뒤) 탈락. 편집기·런타임 공용.
+ * dropPos: 0=어두 어근(앞) 탈락, 1=어말 어근(뒤) 탈락. 결과의 `dropped` 에 뺀 조각을 담는다. 편집기·런타임 공용.
  */
 export function buildDropCompoundProblem(word, comp, pronMap, phonemeView, wordSet, dropPos = null) {
     const chars = [...word];
@@ -407,7 +410,7 @@ export function buildDropCompoundProblem(word, comp, pronMap, phonemeView, wordS
                     break;
             }
             if (wrongs.length >= 2)
-                return { question: word, distractors: [remain, ...wrongs] };
+                return { question: word, distractors: [remain, ...wrongs], dropped };
         }
     }
     return null;

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

@@ -25,6 +25,7 @@ export declare function pickOne<T>(arr: T[]): T | undefined;
 /** 부분 Fisher-Yates: n개만 선택 — arr.length 전체를 교환하지 않고 n번만 교환(대용량 풀 성능용, 공용 sample과 별개). */
 export declare function sample<T>(arr: T[], n: number): T[];
 export declare function getPronMap(): Map<string, string>;
+export declare function pronOfWord(word: string): string;
 /**
  * 후보군에서 n개를 뽑되, 이미 선택된 것들(또는 usedPron으로 미리 배제한 것들)과
  * 발음이 겹치지 않도록 그리디하게 샘플링한다.

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

@@ -103,7 +103,7 @@ export function getPronMap() {
     _cachedPronMapPool = pool;
     return m;
 }
-function pronOfWord(word) {
+export function pronOfWord(word) {
     return getPronMap().get(word) || word;
 }
 /**
@@ -433,7 +433,8 @@ async function _buildUsablePool(opts) {
                 usable = bucket.filter(other => {
                     if (other === w.w || pronOfWord(other) === wPron)
                         return false;
-                    const d = countPhonemeDiff(w.w, other);
+                    // 대립 비교는 두 모드 모두 **발음** — 철자로 세면 '팥빵[팓빵]/팥밥[팓빱]' 이 2개, '틀다/끊다[끈타]' 가 2개로 셌다
+                    const d = countPhonemeDiff(wPron, pronOfWord(other));
                     return contrastCount >= 5 ? d >= 5 : d === contrastCount;
                 });
             }
@@ -442,11 +443,24 @@ async function _buildUsablePool(opts) {
             // 'random' 또는 null(difficulty:false 타입): 음운론적 제약은 없지만,
             // 정답과 오답의 음절수는 같아야 한다(단어 길이만으로 정답을 짐작하지 못하도록) — 본 단어와 다른 단어 + 음절수(글자수) 동일
             const 쓸수있음 = (other) => other !== w.w && other.length === w.w.length && pronOfWord(other) !== wPron;
-            /* 셈(fullCount — 가능 단어 수 안내)은 '오답이 하나라도 있나' 만 본다. 2.2만 후보마다 600개를 끝까지 걸러 칩 한 번에
-               300ms 넘게 멈췄다. 셈은 결과 개수만 쓰고(countUsableWords → pool.length) 오답 목록은 쓰지 않는다. */
+            /* 셈(fullCount — 가능 단어 수 안내)은 **서로 소리가 다른 오답이 보기 수 − 1 개** 있는지까지만 본다(countUsableWords 가 그
+               기준으로 센다). 2.2만 후보마다 600개를 끝까지 걸러 칩 한 번에 300ms 넘게 멈췄다. */
             if (opts.fullCount) {
-                const one = distractorPool.find(쓸수있음);
-                usable = one === undefined ? [] : [one];
+                const need = Math.max(1, (opts.choicesPerItem ?? 3) - 1);
+                const 고름 = [];
+                const 소리 = new Set();
+                for (const other of distractorPool) {
+                    if (!쓸수있음(other))
+                        continue;
+                    const p = pronOfWord(other);
+                    if (소리.has(p))
+                        continue;
+                    소리.add(p);
+                    고름.push(other);
+                    if (고름.length >= need)
+                        break;
+                }
+                usable = 고름;
             }
             else
                 usable = distractorPool.filter(쓸수있음);

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

@@ -19,7 +19,8 @@ export declare function getViableChoseongs(opts?: {
     excludeNoImage?: boolean;
 }): Promise<Set<string>>;
 /** @public 현재 필터(GenOptions) 조건으로 만들 수 있는 정답 단어 수.
- *  fullCount로 샘플링 캡을 우회해 실제 가능 단어 수를 그대로 센다(무작위 왜곡 방지). */
+ *  fullCount로 샘플링 캡을 우회해 실제 가능 단어 수를 그대로 센다(무작위 왜곡 방지).
+ *  보기형 생성과 같게 **서로 소리가 다른 오답이 보기 수(choicesPerItem, 기본 3) − 1 개** 있는 낱말만 센다. */
 export declare function countUsableWords(opts: GenOptions): Promise<number>;
 /** @public 위치별(초성/중성/종성) 선택 가능한 자모 set + 음절 수 set — 실제 단어에 존재하는 값만.
  *