@ihabdevteam/core 0.150.0 → 0.152.0

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

@@ -2,7 +2,8 @@
  * 소음설정 영속 저장소 — TTS/Storage 리졸버, 훈련 로거와 동일한 전역 주입 패턴.
  *
  * 앱(src)에서 configureNoiseSettingsStore()로 Supabase load/save 콜백을 등록하면,
- * TrainingPagePopup이 마운트 시 load()로 초기화하고 변경 시 save()로 기록한다.
+ * TrainingPagePopup이 마운트 시 load()로 초기화하고 변경 시 save()로 기록한다 — 판 중 변경은
+ * 멈춘 뒤 300ms 에 마지막 값만, 판을 떠날 때·pagehide·탭 숨김에는 남은 값을 곧바로.
  * core는 사용자/고객 식별자를 모른다 — 본인(profiles) vs 고객(managed_user) 분기는
  * 앱이 주입한 콜백 내부에서 현재 훈련 대상에 따라 결정한다.
  */
@@ -11,11 +12,14 @@ import type { CoreNoiseSettings } from '../types/training';
 export interface NoiseSettingsStore {
     /** 현재 훈련 대상(본인 또는 고객)의 저장된 소음설정. 없으면 null. */
     load: () => Promise<Partial<CoreNoiseSettings> | null>;
-    /** 현재 훈련 대상의 소음설정을 저장(fire-and-forget). */
+    /**
+     * 현재 훈련 대상의 소음설정을 저장(fire-and-forget).
+     * 훈련 팝업은 판 중 변경(슬라이더 끌기 등)을 **멈춘 뒤 300ms 에 마지막 값만** 넘기고, 떠날 때·pagehide 에 남은 값을 즉시 넘긴다.
+     */
     save: (settings: CoreNoiseSettings) => Promise<void> | void;
     /**
      * **판에 실제로 걸린 설정**이 정해지거나 바뀔 때마다 부른다 — 저장 병합 직후,
-     * `noiseOverride` 적용 직후, 판 중 변경마다. 선택.
+     * `noiseOverride` 적용 직후, 판 중 변경마다(저장과 달리 기다리지 않는다). 선택.
      *
      * `save` 와 따로 두는 까닭: `noiseOverride` 가 걸린 판은 저장을 건너뛴다. 앱이 결과마다
      * 그 판의 소음 조건을 함께 기록한다면 `save` 로는 그 값을 못 받는다 — 저장값으로

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

@@ -4,6 +4,15 @@ export declare const VOWEL_TO_PHONEME: Record<string, {
     glide?: string;
     nucleus: string;
 }>;
+/**
+ * @internal 두 모음(중성 자모)의 활음이 갈리는가 — '음소 구조 같은 단어만' 의 모음 쪽 정의, **대립쌍 표와 단어훈련 런타임이 함께 쓴다.**
+ *
+ * 활음(j·w·ɰ)은 초성 ㅇ·받침처럼 음절의 자리 하나다. ㅏ↔ㅘ(w+ㅏ) 는 모음을 바꾼 게 아니라 자리를 하나 채운 것이라 받침 없음↔있음과 같은
+ * 구조 차이로 본다. 활음 종류가 다른 것(ㅑ↔ㅘ = j↔w)도 표가 구조 차이로 보아 왔으므로 같게 둔다. 활음이 같으면(ㅏ↔ㅓ, ㅑ↔ㅕ) 모음 대립.
+ * 전에는 표(phonemePairSearch.diffHasEmpty)만 이것을 보고 런타임(wordContrast.hasStructureContrast)은 초성 ㅇ·받침만 봐,
+ * 같은 '음소 구조 같은 단어만' 인데 표에서 빠진 사↔솨 가 훈련 오답으로 나왔다.
+ */
+export declare function vowelGlidesDiffer(a: string, b: string): boolean;
 /** 종성 글자 → 음소(대표음) 변환. 매핑에 없으면 원본 유지. */
 export declare function finalToPhoneme(jong: string): string;
 export declare function convertToPhoneme(sel: Record<string, string>): Record<string, string>;

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

@@ -29,6 +29,17 @@ export const VOWEL_TO_PHONEME = {
     ㅟ: { glide: 'w', nucleus: 'ㅣ' },
     ㅢ: { glide: 'ɰ', nucleus: 'ㅣ' },
 };
+/**
+ * @internal 두 모음(중성 자모)의 활음이 갈리는가 — '음소 구조 같은 단어만' 의 모음 쪽 정의, **대립쌍 표와 단어훈련 런타임이 함께 쓴다.**
+ *
+ * 활음(j·w·ɰ)은 초성 ㅇ·받침처럼 음절의 자리 하나다. ㅏ↔ㅘ(w+ㅏ) 는 모음을 바꾼 게 아니라 자리를 하나 채운 것이라 받침 없음↔있음과 같은
+ * 구조 차이로 본다. 활음 종류가 다른 것(ㅑ↔ㅘ = j↔w)도 표가 구조 차이로 보아 왔으므로 같게 둔다. 활음이 같으면(ㅏ↔ㅓ, ㅑ↔ㅕ) 모음 대립.
+ * 전에는 표(phonemePairSearch.diffHasEmpty)만 이것을 보고 런타임(wordContrast.hasStructureContrast)은 초성 ㅇ·받침만 봐,
+ * 같은 '음소 구조 같은 단어만' 인데 표에서 빠진 사↔솨 가 훈련 오답으로 나왔다.
+ */
+export function vowelGlidesDiffer(a, b) {
+    return (VOWEL_TO_PHONEME[a]?.glide ?? '') !== (VOWEL_TO_PHONEME[b]?.glide ?? '');
+}
 /** 종성 글자 → 음소(대표음) 변환. 매핑에 없으면 원본 유지. */
 export function finalToPhoneme(jong) {
     return JONGSEONG_TO_PHONEME[jong] ?? jong;

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

@@ -11,7 +11,13 @@ export interface FilterableWord {
     pos?: string;
     wordType?: string;
 }
-/** 난이도/음절수/품사/유형 필터를 단어 하나에 대해 판정(의미범주 제외 — WordEntry 전용이라 applyFilters에서 별도 처리). */
+/**
+ * 난이도/음절수/품사/유형 필터를 단어 하나에 대해 판정(의미범주 제외 — WordEntry 전용이라 applyFilters에서 별도 처리).
+ *
+ * **섹션 열쇠·값을 어느 언어로 적었든 읽는다** — 넘긴 keys 의 라벨, 지금 언어·ko·en 라벨, 옛 라벨('난이도 등급'·'체언(명사,수사)'),
+ * 코드(`grade`·`noun`·`5+` …) 모두. 전에는 keys 의 라벨만 읽어, 한국어로 저장한 표 구성을 영어 화면에서 열면 등급·음절 필터가
+ * **풀리고** 품사·어종 값은 posMap 에 없어 **모든 단어가 떨어졌다**.
+ */
 export declare function matchesFilters(word: FilterableWord, filterSelected: Record<string, string[]>, keys?: PairFilterKeys): boolean;
 export declare function applyFilters(filterSelected: Record<string, string[]>, words: WordEntry[], keys?: PairFilterKeys): WordEntry[];
 export declare function searchPairs(selectedList: Record<string, string>[], words: WordEntry[], enforcePosition?: number, phonemic?: boolean): WordSearchResultItem[];

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

@@ -1,4 +1,4 @@
-import { VOWEL_TO_PHONEME } from './phonemeConvert';
+import { VOWEL_TO_PHONEME, vowelGlidesDiffer } from './phonemeConvert';
 // ── 음절 분해 ──────────────────────────────────────────────
 const CHO = ['ㄱ', 'ㄲ', 'ㄴ', 'ㄷ', 'ㄸ', 'ㄹ', 'ㅁ', 'ㅂ', 'ㅃ', 'ㅅ', 'ㅆ', 'ㅇ', 'ㅈ', 'ㅉ', 'ㅊ', 'ㅋ', 'ㅌ', 'ㅍ', 'ㅎ'];
 const JUNG = ['ㅏ', 'ㅐ', 'ㅑ', 'ㅒ', 'ㅓ', 'ㅔ', 'ㅕ', 'ㅖ', 'ㅗ', 'ㅘ', 'ㅙ', 'ㅚ', 'ㅛ', 'ㅜ', 'ㅝ', 'ㅞ', 'ㅟ', 'ㅠ', 'ㅡ', 'ㅢ', 'ㅣ'];
@@ -91,8 +91,8 @@ function diffHasEmptyPair(section, vals) {
     // 구조상 '비움'으로 보는 경우만 true:
     //  - 종성: 받침 없음('없음' / '')
     //  - 초성: 무자음 ㅇ (글자 분해='ㅇ' / 발음 분해='없음')
-    // 활음 '없음'은 제외한다 — 활음 유무(예: ㅐ↔ㅙ = 없음↔w)는 음절 '구조' 차이가 아니라
-    // 정당한 '모음 대립'이므로(글자 모드도 ㅐ↔ㅙ를 모음 대립으로 인정) 걸러내면 안 된다.
+    // '활음' 섹션의 '없음'은 비움으로 보지 않는다 — 발음 모드에서 사용자가 활음 자리를 **직접 골라** 찾는 대립(ㅐ↔ㅙ = 없음↔w)이라
+    // 그 검색 결과를 이 필터가 통째로 지우면 안 된다.
     const isEmpty = (v) => v === '' ||
         (section === '종성' && v === '없음') ||
         (section === '초성' && (v === 'ㅇ' || v === '없음'));
@@ -101,13 +101,11 @@ function diffHasEmptyPair(section, vals) {
     // 모음(글자 모드) 활음 구조 차이: 두 모음의 반모음(활음)이 다르면 음절 '구조' 차이로 본다.
     //  예) ㅓ(단모음) ↔ ㅟ(w+ㅣ), ㅏ ↔ ㅘ(w+ㅏ), ㅐ ↔ ㅙ(w+ㅐ) → 구조 상이 → 제외.
     //  같은 활음끼리(ㅏ↔ㅓ 둘 다 없음, ㅑ↔ㅕ 둘 다 j)는 정당한 모음 대립 → 유지.
-    //  발음 모드는 모음=핵모음이라 VOWEL_GLIDE에 없어(둘 다 '') 영향 없음. 활음 대립은
+    //  발음 모드는 모음=핵모음이라 둘 다 활음 없음으로 읽혀 영향 없음. 활음 대립은
     //  별도 '활음' 섹션에서 처리되므로 여기(모음)에서 걸러도 활음 지정 대립과 충돌하지 않는다.
-    if (section === '모음') {
-        const glideOf = (v) => VOWEL_GLIDE[v] ?? '';
-        if (glideOf(vals[0]) !== glideOf(vals[1]))
-            return true;
-    }
+    //  단어훈련 런타임(wordContrast.hasStructureContrast)도 **같은 함수**로 판정한다.
+    if (section === '모음' && vowelGlidesDiffer(vals[0], vals[1]))
+        return true;
     return false;
 }
 // ── 필터 적용 ──────────────────────────────────────────────
@@ -117,6 +115,7 @@ const POS_GROUP_MAP_KO = {
     '용언(동사,형용사)': ['동', '형'],
     '수식언(부사,관형사)': ['부', '관'],
 };
+import { POS_CODE_TARGETS, WORD_TYPE_CODE_VALUES, wordAttributeSectionOf, wordAttributeValueCodeOf } from './wordAttributeFilterCodes';
 const DEFAULT_PAIR_FILTER_KEYS = {
     difficulty: '난이도 등급',
     syllables: '음절 수',
@@ -126,30 +125,55 @@ const DEFAULT_PAIR_FILTER_KEYS = {
     posMap: POS_GROUP_MAP_KO,
     typeMap: WORD_TYPE_MAP_KO,
 };
-/** 난이도/음절수/품사/유형 필터를 단어 하나에 대해 판정(의미범주 제외 — WordEntry 전용이라 applyFilters에서 별도 처리). */
+const 모은것 = new WeakMap();
+function 모으기(filterSelected, keys) {
+    const 있음 = 모은것.get(filterSelected);
+    if (있음 && 있음.keys === keys)
+        return 있음.값;
+    const 값 = { grades: [], syls: [], poses: [], types: [] };
+    const 칸 = { grade: 값.grades, syllables: 값.syls, pos: 값.poses, wordType: 값.types };
+    for (const [label, raw] of Object.entries(filterSelected ?? {})) {
+        /* 섹션은 넘긴 keys 의 라벨이면 그것, 아니면 어느 언어·옛 라벨·코드든 읽는다(wordAttributeSectionOf) */
+        const s = label === keys.difficulty ? 'grade' : label === keys.syllables ? 'syllables'
+            : label === keys.partOfSpeech ? 'pos' : label === keys.wordType ? 'wordType'
+                : wordAttributeSectionOf(label);
+        if (!s)
+            continue;
+        for (const v of Array.isArray(raw) ? raw : typeof raw === 'string' ? [raw] : [])
+            if (!칸[s].includes(v))
+                칸[s].push(v);
+    }
+    모은것.set(filterSelected, { keys, 값 });
+    return 값;
+}
+/**
+ * 난이도/음절수/품사/유형 필터를 단어 하나에 대해 판정(의미범주 제외 — WordEntry 전용이라 applyFilters에서 별도 처리).
+ *
+ * **섹션 열쇠·값을 어느 언어로 적었든 읽는다** — 넘긴 keys 의 라벨, 지금 언어·ko·en 라벨, 옛 라벨('난이도 등급'·'체언(명사,수사)'),
+ * 코드(`grade`·`noun`·`5+` …) 모두. 전에는 keys 의 라벨만 읽어, 한국어로 저장한 표 구성을 영어 화면에서 열면 등급·음절 필터가
+ * **풀리고** 품사·어종 값은 posMap 에 없어 **모든 단어가 떨어졌다**.
+ */
 export function matchesFilters(word, filterSelected, keys = DEFAULT_PAIR_FILTER_KEYS) {
-    const grades = filterSelected[keys.difficulty];
-    if (grades?.length && !grades.some(g => word.grade === g.replace(/\D/g, '')))
+    const { grades, syls, poses, types } = 모으기(filterSelected, keys);
+    if (grades.length && !grades.some(g => word.grade === (wordAttributeValueCodeOf('grade', g) ?? g.replace(/\D/g, ''))))
         return false;
-    const syls = filterSelected[keys.syllables];
-    if (syls?.length) {
+    if (syls.length) {
         const len = word.syllables ?? 0;
         const match = syls.some(syl => {
-            if (syl === keys.syllable5plus)
+            const code = syl === keys.syllable5plus ? '5+' : wordAttributeValueCodeOf('syllables', syl);
+            if (code === '5+')
                 return len >= 5;
-            return len === parseInt(syl);
+            return len === parseInt(code ?? syl);
         });
         if (!match)
             return false;
     }
-    const poses = filterSelected[keys.partOfSpeech];
-    if (poses?.length) {
-        const targets = poses.flatMap(pos => keys.posMap[pos] ?? [pos]);
+    if (poses.length) {
+        const targets = poses.flatMap(pos => keys.posMap[pos] ?? POS_CODE_TARGETS[wordAttributeValueCodeOf('pos', pos) ?? ''] ?? [pos]);
         if (!targets.some(p => (word.pos ?? '').includes(p)))
             return false;
     }
-    const types = filterSelected[keys.wordType];
-    if (types?.length && !types.some(t => word.wordType === keys.typeMap[t]))
+    if (types.length && !types.some(t => word.wordType === (keys.typeMap[t] ?? WORD_TYPE_CODE_VALUES[wordAttributeValueCodeOf('wordType', t) ?? ''])))
         return false;
     return true;
 }

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

@@ -0,0 +1,8 @@
+/**
+ * 새 창으로 열어도 되는 주소인가(내부).
+ *
+ * SideNav·Header 는 메뉴 항목의 `href` 를 `window.open` 으로 연다. 항목이 서버·설정에서 오면 `javascript:alert(1)` 같은 주소가
+ * 그대로 열려 스크립트가 돌 수 있었다. **http(s)·상대 경로·mailto·tel** 만 연다.
+ * 판정은 공백·제어 문자를 걷은 뒤 스킴으로 한다 — 브라우저는 스킴 안의 탭·줄바꿈을 무시해 `java(탭)script:` 도 스크립트로 연다.
+ */
+export declare function isSafeOpenHref(href: unknown): href is string;

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

@@ -0,0 +1,24 @@
+/**
+ * 새 창으로 열어도 되는 주소인가(내부).
+ *
+ * SideNav·Header 는 메뉴 항목의 `href` 를 `window.open` 으로 연다. 항목이 서버·설정에서 오면 `javascript:alert(1)` 같은 주소가
+ * 그대로 열려 스크립트가 돌 수 있었다. **http(s)·상대 경로·mailto·tel** 만 연다.
+ * 판정은 공백·제어 문자를 걷은 뒤 스킴으로 한다 — 브라우저는 스킴 안의 탭·줄바꿈을 무시해 `java(탭)script:` 도 스크립트로 연다.
+ */
+export function isSafeOpenHref(href) {
+    if (typeof href !== 'string')
+        return false;
+    let 걷은 = '';
+    for (const ch of href) {
+        const c = ch.charCodeAt(0);
+        if (c <= 0x20 || (c >= 0x7f && c <= 0x9f))
+            continue;
+        걷은 += ch;
+    }
+    if (!걷은)
+        return false;
+    const m = /^([a-zA-Z][a-zA-Z0-9+.-]*):/.exec(걷은);
+    if (!m)
+        return true; // 스킴이 없다 — 상대 경로(`/help`·`./a`·`?q`·`#x`)·`//host` 는 지금 문서의 스킴을 따른다
+    return ['http', 'https', 'mailto', 'tel'].includes(m[1].toLowerCase());
+}

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

@@ -9,10 +9,26 @@ export interface SavedWordTable {
     description?: string;
     /** 대립쌍표를 만든 검색 구성 — 저장 시 함께 남겨 수정 시 검색 패널을 복원한다. */
     searchConfig?: WordTableSearchConfig;
+    /** 복습표면 맨 처음 원본 표의 id — `reviewMeta` 가 준다. 있으면 `reviewTableName` 이 이름 파싱보다 먼저 쓴다. */
+    reviewOf?: string;
+    /** 몇 번째 복습인가(1부터, 0 = 복습표 아님) — `reviewMeta` 가 준다. 없으면 옛 표로 보고 이름을 파싱한다. */
+    reviewRound?: number;
 }
 export declare function getSavedTables(): SavedWordTable[];
-export declare function saveTable(name: string, items: WordSearchResultItem[], description?: string, searchConfig?: WordTableSearchConfig): SavedWordTable;
-/** 저장된 단어표를 갱신한다(수정 저장). 지정한 필드만 덮어쓴다. */
-export declare function updateSavedTable(id: string, patch: Partial<Pick<SavedWordTable, 'name' | 'items' | 'description' | 'searchConfig' | 'group'>>): void;
+/**
+ * 새 표를 목록 맨 앞에 저장한다.
+ *
+ * @returns 저장한 표. **저장소에 적지 못하면 `null`** — 예외를 삼키고 만든 표를 그대로 돌려주던 때는
+ *          부르는 쪽이 '저장했습니다' 를 띄웠는데 목록에는 표가 없었다. `null` 이면 실패를 알려야 한다.
+ */
+export declare function saveTable(name: string, items: WordSearchResultItem[], description?: string, searchConfig?: WordTableSearchConfig): SavedWordTable | null;
+/**
+ * 저장된 단어표를 갱신한다(수정 저장). 지정한 필드만 덮어쓴다.
+ *
+ * @returns 저장소에 적었으면 `true`, **적지 못하면 `false`**(용량 초과·저장 거부) — 전에는 `void` 로 실패를 삼켜
+ *          수정이 저장된 것처럼 보였다. 없는 id 는 바꿀 것이 없어 목록을 그대로 다시 적고 `true`.
+ */
+export declare function updateSavedTable(id: string, patch: Partial<Pick<SavedWordTable, 'name' | 'items' | 'description' | 'searchConfig' | 'group' | 'reviewOf' | 'reviewRound'>>): boolean;
 export declare function deleteTable(id: string): void;
+/** 표를 복사해 목록 맨 앞에 둔다. 원본이 없거나 **저장소에 적지 못하면 `null`**. */
 export declare function duplicateTable(id: string): SavedWordTable | null;

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

@@ -20,6 +20,22 @@ export function getSavedTables() {
         return [];
     }
 }
+/** 목록을 통째로 적는다. 저장소가 가득 찼거나(QuotaExceededError) 거부되면(사파리 프라이빗 모드) false. */
+function 적기(tables) {
+    try {
+        localStorage.setItem(STORAGE_KEY, JSON.stringify(tables));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 새 표를 목록 맨 앞에 저장한다.
+ *
+ * @returns 저장한 표. **저장소에 적지 못하면 `null`** — 예외를 삼키고 만든 표를 그대로 돌려주던 때는
+ *          부르는 쪽이 '저장했습니다' 를 띄웠는데 목록에는 표가 없었다. `null` 이면 실패를 알려야 한다.
+ */
 export function saveTable(name, items, description, searchConfig) {
     const tables = getSavedTables();
     const newTable = {
@@ -30,27 +46,23 @@ export function saveTable(name, items, description, searchConfig) {
         description,
         searchConfig,
     };
-    try {
-        localStorage.setItem(STORAGE_KEY, JSON.stringify([newTable, ...tables]));
-    }
-    catch { /* noop */ }
-    return newTable;
+    return 적기([newTable, ...tables]) ? newTable : null;
 }
-/** 저장된 단어표를 갱신한다(수정 저장). 지정한 필드만 덮어쓴다. */
+/**
+ * 저장된 단어표를 갱신한다(수정 저장). 지정한 필드만 덮어쓴다.
+ *
+ * @returns 저장소에 적었으면 `true`, **적지 못하면 `false`**(용량 초과·저장 거부) — 전에는 `void` 로 실패를 삼켜
+ *          수정이 저장된 것처럼 보였다. 없는 id 는 바꿀 것이 없어 목록을 그대로 다시 적고 `true`.
+ */
 export function updateSavedTable(id, patch) {
     const tables = getSavedTables().map(t => t.id === id ? { ...t, ...patch } : t);
-    try {
-        localStorage.setItem(STORAGE_KEY, JSON.stringify(tables));
-    }
-    catch { /* noop */ }
+    return 적기(tables);
 }
 export function deleteTable(id) {
     const tables = getSavedTables().filter(t => t.id !== id);
-    try {
-        localStorage.setItem(STORAGE_KEY, JSON.stringify(tables));
-    }
-    catch { /* noop */ }
+    적기(tables);
 }
+/** 표를 복사해 목록 맨 앞에 둔다. 원본이 없거나 **저장소에 적지 못하면 `null`**. */
 export function duplicateTable(id) {
     const tables = getSavedTables();
     const original = tables.find(t => t.id === id);
@@ -63,9 +75,5 @@ export function duplicateTable(id) {
         name: `${original.name} (복사)`,
         savedAt: new Date().toISOString(),
     };
-    try {
-        localStorage.setItem(STORAGE_KEY, JSON.stringify([copy, ...tables]));
-    }
-    catch { /* noop */ }
-    return copy;
+    return 적기([copy, ...tables]) ? copy : null;
 }

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

@@ -7,7 +7,16 @@ export declare function 한글순(a: string, b: string): number;
  * (`10` 이 `9` 앞에 선다). 값을 숫자 조각과 글자 조각으로 나눠 앞에서부터 견준다 —
  * `회차 9` 가 `회차 10` 앞, `12.25%` 가 `12.5%` 앞, `-10 dB` 가 `-5 dB` 앞. 숫자 조각은 글자 조각 앞에 선다.
  *
+ * 전화번호 꼴(숫자·하이픈·빈칸만, 숫자 9–11자리, 0 으로 시작 — 1 로 시작하면 하이픈·빈칸이 있을 때만)은 숫자만 뽑아 글자로 견준다 —
+ * `010-1234-5678` 이 `02-123-4567` 앞, `01012345678` 과 `010-1234-5678` 이 같은 규칙.
+ *
  * 비어 있는 값(`null`·`undefined`·NaN)은 빈 글자로 본다 — 부르는 쪽이 이미
  * `?? ''` 로 채워 넘기던 것과 같은 뜻이다.
  */
 export declare function 칸순(a: unknown, b: unknown): number;
+/**
+ * 표 정렬 한 번의 비교 — 칸순에 방향을 입히되 **빈 값은 오름·내림 모두 맨 뒤.**
+ * 방향을 `-칸순` 으로 뒤집기만 하면 빈 값이 오름차순 맨 앞·내림차순 맨 뒤로 오가, 표마다 빈 줄이 다른 끝에 섰다.
+ * ListPopup 과 useTableSort().sortRows 가 함께 쓴다.
+ */
+export declare function 칸순빈값뒤(a: unknown, b: unknown, asc: boolean): number;

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

@@ -50,6 +50,20 @@ function 조각내기(s) {
     조각열쇠.set(s, out);
     return out;
 }
+/* **전화번호 꼴**(숫자·하이픈·빈칸만, 숫자 9–11자리, 0 으로 시작 — 1 로 시작하면 하이픈·빈칸이 있을 때만)은 숫자만 뽑은 **글자 조각 하나**가 열쇠다.
+   조각으로 쪼개 수로 읽으면 '02-123-4567'(2) 이 '010-1234-5678'(10) 앞에, 하이픈 없는 '01012345678' 은 수 하나라
+   '010-…' 뒤에 서서, 같은 번호가 하이픈 유무로 표의 다른 자리로 갔다.
+   두 값이 모두 전화 꼴이면 숫자 글자끼리 견주는 셈이 된다. 한쪽만 전화 꼴일 때도 **값마다 열쇠가 하나로 정해져** 있어야
+   차례가 돌지 않는다(값 쌍마다 규칙을 고르면 A<B<C<A 가 생긴다) — 글자 조각이라 수 조각 뒤, 다른 글자와는 한국어 차례. */
+function 전화열쇠(s) {
+    if (!/^[\d\s-]+$/.test(s))
+        return null;
+    const 숫자 = s.replace(/\D/g, '');
+    if (숫자.length < 9 || 숫자.length > 11)
+        return null;
+    // 0 으로 시작하면 전화. 1 로 시작하면 하이픈·빈칸이 있을 때만 — 하이픈 없는 '1234567890' 같은 번호 ID 는 수로 둔다
+    return 숫자[0] === '0' || (숫자[0] === '1' && s !== 숫자) ? 숫자 : null;
+}
 /**
  * 표의 한 칸끼리 견준다 — **숫자는 숫자로, 글자 속 숫자도 수로.**
  *
@@ -57,6 +71,9 @@ function 조각내기(s) {
  * (`10` 이 `9` 앞에 선다). 값을 숫자 조각과 글자 조각으로 나눠 앞에서부터 견준다 —
  * `회차 9` 가 `회차 10` 앞, `12.25%` 가 `12.5%` 앞, `-10 dB` 가 `-5 dB` 앞. 숫자 조각은 글자 조각 앞에 선다.
  *
+ * 전화번호 꼴(숫자·하이픈·빈칸만, 숫자 9–11자리, 0 으로 시작 — 1 로 시작하면 하이픈·빈칸이 있을 때만)은 숫자만 뽑아 글자로 견준다 —
+ * `010-1234-5678` 이 `02-123-4567` 앞, `01012345678` 과 `010-1234-5678` 이 같은 규칙.
+ *
  * 비어 있는 값(`null`·`undefined`·NaN)은 빈 글자로 본다 — 부르는 쪽이 이미
  * `?? ''` 로 채워 넘기던 것과 같은 뜻이다.
  */
@@ -66,7 +83,12 @@ export function 칸순(a, 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 열쇠 = (v, s) => {
+        if (typeof v === 'number' && !Number.isNaN(v))
+            return [v];
+        const 전화 = 전화열쇠(s);
+        return 전화 !== null ? [전화] : 조각내기(s);
+    };
     const ka = 열쇠(a, sa), kb = 열쇠(b, sb);
     const n = Math.min(ka.length, kb.length);
     for (let i = 0; i < n; i++) {
@@ -88,3 +110,17 @@ export function 칸순(a, b) {
         return ka.length - kb.length;
     return 한글순(sa, sb);
 }
+/* 빈 값 — null·undefined·NaN·빈 글자(빈칸만 있는 글자 포함). 칸순이 '' 로 보는 것과 같은 범위. */
+const 빈칸값 = (v) => v == null || (typeof v === 'number' && Number.isNaN(v)) || (typeof v === 'string' && v.trim() === '');
+/**
+ * 표 정렬 한 번의 비교 — 칸순에 방향을 입히되 **빈 값은 오름·내림 모두 맨 뒤.**
+ * 방향을 `-칸순` 으로 뒤집기만 하면 빈 값이 오름차순 맨 앞·내림차순 맨 뒤로 오가, 표마다 빈 줄이 다른 끝에 섰다.
+ * ListPopup 과 useTableSort().sortRows 가 함께 쓴다.
+ */
+export function 칸순빈값뒤(a, b, asc) {
+    const ea = 빈칸값(a), eb = 빈칸값(b);
+    if (ea || eb)
+        return ea === eb ? 0 : ea ? 1 : -1;
+    const c = 칸순(a, b);
+    return asc ? c : -c;
+}

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

@@ -0,0 +1,31 @@
+/** @public 공용 속성 필터 섹션 코드 */
+export type WordAttributeSectionCode = 'grade' | 'syllables' | 'pos' | 'wordType';
+/**
+ * @public 공용 속성 필터를 **언어와 무관한 코드**로 담은 모양 — 저장(DB config·로컬 저장소)용.
+ * 예: `{ grade: ['1', '2'], syllables: ['5+'], pos: ['noun'], wordType: ['sino'] }`
+ */
+export type WordAttributeFilterCodes = Partial<Record<WordAttributeSectionCode, string[]>>;
+/** 품사 코드 → 사전 품사 약자(단어의 pos 에 들어 있는지 본다) · 어종 코드 → 사전 어종 값 */
+export declare const POS_CODE_TARGETS: Record<string, string[]>;
+export declare const WORD_TYPE_CODE_VALUES: Record<string, string>;
+/** 섹션 라벨(어느 언어든·옛 라벨·코드) → 섹션 코드. 속성 섹션이 아니면 null. */
+export declare function wordAttributeSectionOf(label: string): WordAttributeSectionCode | null;
+/** 한 섹션의 값(코드·어느 언어 라벨·옛 라벨) → 값 코드. 못 읽으면 null. */
+export declare function wordAttributeValueCodeOf(section: WordAttributeSectionCode, value: string): string | null;
+/**
+ * @public filterSelected(라벨 열쇠·라벨 값, 어느 언어든 섞여 있어도) → **코드 모양**. 저장할 때 쓴다.
+ * 속성 섹션(등급·음절 수·품사·어종)만 담고, 그 밖의 섹션(초성·선택·단어 입력 등)은 뺀다. 못 읽는 값은 버린다.
+ */
+export declare function toWordAttributeFilterCodes(selected: Record<string, unknown> | null | undefined): WordAttributeFilterCodes;
+/**
+ * @public 코드 모양 → 지정한 언어(기본: 지금 i18n 언어)의 **라벨 filterSelected**. FilterPanel 의 selected 로 그대로 쓴다.
+ */
+export declare function wordAttributeFilterFromCodes(codes: WordAttributeFilterCodes | null | undefined, lng?: string): Record<string, string[]>;
+/**
+ * @public filterSelected 의 속성 섹션을 **지정한 언어(기본: 지금 언어)의 라벨**로 다시 적는다 — 다른 언어·옛 라벨로 저장된 구성을
+ * 열 때, 언어가 바뀐 뒤 상태를 맞출 때 쓴다(칩이 꺼진 채로 보이던 것). 속성 밖의 섹션은 그대로 둔다. 같은 섹션이 두 언어로
+ * 들어 있으면 합친다.
+ */
+export declare function normalizeWordAttributeFilter<T extends Record<string, unknown>>(selected: T, lng?: string): T;
+/** 라벨이 어느 언어의 섹션 라벨인가 — 토글이 그 언어로 값을 적게 */
+export declare function wordAttributeLabelLanguageOf(label: string): string;

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

@@ -0,0 +1,163 @@
+/**
+ * 공용 속성 필터(등급·음절 수·품사·어종)의 **고정 코드**와 라벨 사이를 오간다.
+ *
+ * 단어표·대립쌍표의 filterSelected 는 **번역된 라벨**을 섹션 열쇠·값으로 쓴다(`{ '품사': ['체언(명사, 수사)'] }`).
+ * 그래서 한국어로 저장한 표 구성을 영어 화면에서 열거나, 화면을 연 채 언어가 바뀌면(말귀: 고객 세션이 그 사람의 언어를 적용)
+ * 영어 열쇠('Part of Speech')로는 한국어 값이 안 읽혀 **필터가 풀리거나**, 품사 값이 posMap 에 없어 **모든 단어가 떨어졌다**.
+ * 여기서 섹션·값을 언어와 무관한 코드로 읽는다 — 코드, 지금 언어·ko·en 라벨, 옛 라벨('난이도 등급'·'체언(명사,수사)') 모두.
+ *
+ * 코드: 섹션 `grade`·`syllables`·`pos`·`wordType`, 값 등급 `'1'`~`'4'` · 음절 `'1'`~`'4'`·`'5+'` ·
+ * 품사 `noun`·`verb`·`modifier` · 어종 `native`·`sino`·`foreign`·`mixed`.
+ * (useWordTrainingFilter 의 POS_CODES·toAttrCodes 와 같은 코드다.)
+ */
+import i18n from '../i18n';
+const 섹션들 = ['grade', 'syllables', 'pos', 'wordType'];
+const 등급값 = ['1', '2', '3', '4'];
+const 음절값 = ['1', '2', '3', '4', '5+'];
+const 품사값 = ['noun', 'verb', 'modifier'];
+const 어종값 = ['native', 'sino', 'foreign', 'mixed'];
+const 코드값 = { grade: 등급값, syllables: 음절값, pos: 품사값, wordType: 어종값 };
+/** 품사 코드 → 사전 품사 약자(단어의 pos 에 들어 있는지 본다) · 어종 코드 → 사전 어종 값 */
+export const POS_CODE_TARGETS = { noun: ['명', '수'], verb: ['동', '형'], modifier: ['부', '관'] };
+export const WORD_TYPE_CODE_VALUES = { native: '고유', sino: '한자', foreign: '외래', mixed: '혼종' };
+/* 사전 밖의 옛 라벨 — phonemePairSearch 의 DEFAULT_PAIR_FILTER_KEYS 가 쓰던 것(쉼표 뒤 빈칸 없음·'난이도 등급') */
+const 옛섹션 = { grade: ['난이도 등급'] };
+const 옛값 = {
+    pos: { noun: ['체언(명사,수사)'], verb: ['용언(동사,형용사)'], modifier: ['수식언(부사,관형사)'] },
+};
+/* 언어마다 한 번 만든다 — matchesFilters 는 낱말(2만여 개)마다 불린다. 사전이 더해지면(addResourceBundle) 비운다 */
+const 사전들 = new Map();
+try {
+    i18n.store?.on?.('added', () => 사전들.clear());
+}
+catch { /* 없는 환경 */ }
+function 사전(lng) {
+    const 있음 = 사전들.get(lng);
+    if (있음)
+        return 있음;
+    const t = i18n.getFixedT(lng);
+    const d = {
+        섹션: {
+            grade: t('wordSearch.filter.difficulty', '등급'),
+            syllables: t('wordSearch.filter.syllables', '음절 수'),
+            pos: t('wordSearch.filter.partOfSpeech', '품사'),
+            wordType: t('wordSearch.filter.wordType', '유형'),
+        },
+        값: {
+            grade: Object.fromEntries(등급값.map((n) => [n, t('wordSearch.filter.grade', { n: Number(n), defaultValue: `${n}등급` })])),
+            syllables: {
+                ...Object.fromEntries(['1', '2', '3', '4'].map((n) => [n, t('wordSearch.filter.syllable', { n: Number(n), defaultValue: `${n}음절` })])),
+                '5+': t('wordSearch.filter.syllable5plus', '5음절 이상'),
+            },
+            pos: {
+                noun: t('wordSearch.filter.pos.noun', '체언(명사, 수사)'),
+                verb: t('wordSearch.filter.pos.verb', '용언(동사, 형용사)'),
+                modifier: t('wordSearch.filter.pos.modifier', '수식언(부사, 관형사)'),
+            },
+            wordType: {
+                native: t('wordSearch.filter.type.native', '고유어'),
+                sino: t('wordSearch.filter.type.sino', '한자어'),
+                foreign: t('wordSearch.filter.type.foreign', '외래어'),
+                mixed: t('wordSearch.filter.type.mixed', '혼종어'),
+            },
+        },
+    };
+    사전들.set(lng, d);
+    return d;
+}
+const 언어들 = () => Array.from(new Set([i18n.language, 'ko', 'en'].filter((x) => !!x)));
+/** 섹션 라벨(어느 언어든·옛 라벨·코드) → 섹션 코드. 속성 섹션이 아니면 null. */
+export function wordAttributeSectionOf(label) {
+    if (섹션들.includes(label))
+        return label;
+    for (const lng of 언어들()) {
+        const d = 사전(lng);
+        for (const s of 섹션들)
+            if (d.섹션[s] === label)
+                return s;
+    }
+    for (const s of 섹션들)
+        if (옛섹션[s]?.includes(label))
+            return s;
+    return null;
+}
+/** 한 섹션의 값(코드·어느 언어 라벨·옛 라벨) → 값 코드. 못 읽으면 null. */
+export function wordAttributeValueCodeOf(section, value) {
+    if (코드값[section].includes(value))
+        return value;
+    for (const lng of 언어들()) {
+        const 표 = 사전(lng).값[section];
+        for (const [code, label] of Object.entries(표))
+            if (label === value)
+                return code;
+    }
+    for (const [code, labels] of Object.entries(옛값[section] ?? {}))
+        if (labels.includes(value))
+            return code;
+    /* 등급·음절은 숫자로도 읽는다('Grade 3'·'3등급'·'6음절') — 사전에 없는 꼴이 와도 풀리지 않게 */
+    if (section === 'grade' || section === 'syllables') {
+        const n = parseInt(value.replace(/\D/g, ''), 10);
+        if (Number.isFinite(n) && n >= 1) {
+            if (section === 'grade')
+                return n <= 4 ? String(n) : null;
+            return n >= 5 ? '5+' : String(n);
+        }
+    }
+    return null;
+}
+const 배열로 = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string') : typeof v === 'string' && v ? [v] : []);
+/**
+ * @public filterSelected(라벨 열쇠·라벨 값, 어느 언어든 섞여 있어도) → **코드 모양**. 저장할 때 쓴다.
+ * 속성 섹션(등급·음절 수·품사·어종)만 담고, 그 밖의 섹션(초성·선택·단어 입력 등)은 뺀다. 못 읽는 값은 버린다.
+ */
+export function toWordAttributeFilterCodes(selected) {
+    const out = {};
+    for (const [k, v] of Object.entries(selected ?? {})) {
+        const s = wordAttributeSectionOf(k);
+        if (!s)
+            continue;
+        for (const raw of 배열로(v)) {
+            const c = wordAttributeValueCodeOf(s, raw);
+            if (!c)
+                continue;
+            const arr = (out[s] ??= []);
+            if (!arr.includes(c))
+                arr.push(c);
+        }
+    }
+    return out;
+}
+/**
+ * @public 코드 모양 → 지정한 언어(기본: 지금 i18n 언어)의 **라벨 filterSelected**. FilterPanel 의 selected 로 그대로 쓴다.
+ */
+export function wordAttributeFilterFromCodes(codes, lng = i18n.language) {
+    const d = 사전(lng || 'ko');
+    const out = {};
+    for (const s of 섹션들) {
+        const labels = (codes?.[s] ?? []).map((c) => d.값[s][c]).filter((x) => !!x);
+        if (labels.length)
+            out[d.섹션[s]] = labels;
+    }
+    return out;
+}
+/**
+ * @public filterSelected 의 속성 섹션을 **지정한 언어(기본: 지금 언어)의 라벨**로 다시 적는다 — 다른 언어·옛 라벨로 저장된 구성을
+ * 열 때, 언어가 바뀐 뒤 상태를 맞출 때 쓴다(칩이 꺼진 채로 보이던 것). 속성 밖의 섹션은 그대로 둔다. 같은 섹션이 두 언어로
+ * 들어 있으면 합친다.
+ */
+export function normalizeWordAttributeFilter(selected, lng = i18n.language) {
+    const 남김 = {};
+    for (const [k, v] of Object.entries(selected ?? {}))
+        if (!wordAttributeSectionOf(k))
+            남김[k] = v;
+    return { ...남김, ...wordAttributeFilterFromCodes(toWordAttributeFilterCodes(selected), lng) };
+}
+/** 라벨이 어느 언어의 섹션 라벨인가 — 토글이 그 언어로 값을 적게 */
+export function wordAttributeLabelLanguageOf(label) {
+    for (const lng of 언어들()) {
+        const d = 사전(lng);
+        if (섹션들.some((s) => d.섹션[s] === label))
+            return lng;
+    }
+    return i18n.language || 'ko';
+}

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

@@ -16,7 +16,9 @@ export declare const hasSel: (v: string | string[] | null | undefined) => boolea
  * 두 (표준발음) 분해배열 A·B가 '음절 구조'에서 달라지는 자리가 있는지.
  * 초성 ㅇ(무음)은 '초성 없음', 종성 0은 '받침 없음'(둘 다 구조상 '비움')으로 본다.
  * 어떤 자리에서 초성 ㅇ 유무 또는 받침 유무가 뒤바뀌면, 자음 '교체'가 아니라 음절 '구조' 차이이므로
- * 청각 변별 오답으로 부적절 → true(제외 대상). 자음↔자음, 모음↔모음 교체는 false.
+ * 청각 변별 오답으로 부적절 → true(제외 대상). 자음↔자음 교체는 false.
+ * 모음은 **활음이 갈리면**(ㅏ↔ㅘ·ㅐ↔ㅙ·ㅑ↔ㅘ) 구조 차이, 활음이 같으면(ㅏ↔ㅓ·ㅑ↔ㅕ) 모음 교체라 false —
+ * 대립쌍 표('음소 구조 같은 단어만', phonemePairSearch)와 같은 함수(vowelGlidesDiffer)로 판정한다.
  */
 export declare function hasStructureContrast(A: Decomp, B: Decomp): boolean;
 /** 표준발음 기준 오답 필터에 필요한 의존성 */
@@ -27,7 +29,7 @@ export interface ContrastFilterOpts {
     pronOf: (w: string) => string;
     /** 표준발음 문자열 → 음절 분해(캐시 권장). sameStructureOnly일 때만 필요. */
     decompOf?: (pron: string) => Decomp;
-    /** true면 구조 대립(초성 ㅇ 유무·받침 유무)도 제외(decompOf 필요). */
+    /** true면 구조 대립(초성 ㅇ 유무·활음 유무·종류·받침 유무)도 제외(decompOf 필요). */
     sameStructureOnly?: boolean;
 }
 /**