@ihabdevteam/core 0.322.0 → 0.324.0

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

@@ -8,15 +8,20 @@ function decompose(char) {
     if (code < 0 || code > 11171)
         return null;
     return {
-        초성: CHO[Math.floor(code / 588)],
-        모음: JUNG[Math.floor((code % 588) / 28)],
-        종성: JONG[code % 28] || '',
+        onset: CHO[Math.floor(code / 588)],
+        vowel: JUNG[Math.floor((code % 588) / 28)],
+        coda: JONG[code % 28] || '',
     };
 }
-const SECTION_KEYS = ['초성', '모음', '종성', '활음'];
-function isSectionKey(value) {
-    return SECTION_KEYS.includes(value);
-}
+/* 음절 자리 코드는 **아래 모듈**에 있다 — `phonemeConvert` 도 함께 쓰는데, 여기 두면
+   `phonemePairSearch ↔ phonemeConvert` 돌림 import 가 된다(한 번 그렇게 해 시험 338 꾸러미가
+   무너졌다, 2026-10-13). */
+import { toPhonemeCodes, toLegacyPhonemeKey, isPhonemeSectionCode, PHONEME_SECTION_CODES, PHONEME_NONE } from './phonemeSectionCodes';
+export { toPhonemeCodes, PHONEME_NONE } from './phonemeSectionCodes';
+const SECTION_KEYS = PHONEME_SECTION_CODES;
+const NONE = PHONEME_NONE;
+const isSectionKey = isPhonemeSectionCode;
+const toCodes = toPhonemeCodes;
 // 발음형 분해: 모음을 활음 + 핵모음으로 분리
 const VOWEL_GLIDE = {
     ㅑ: 'j', ㅒ: 'j', ㅕ: 'j', ㅖ: 'j', ㅛ: 'j', ㅠ: 'j',
@@ -38,10 +43,10 @@ function decomposePhonemicSyllable(char) {
     const rawJung = JUNG[jungIdx];
     const rawJong = JONG[jongIdx];
     return {
-        초성: rawCho === 'ㅇ' ? '없음' : rawCho,
-        활음: VOWEL_GLIDE[rawJung] ?? '없음',
-        모음: VOWEL_NUCLEUS[rawJung] ?? rawJung,
-        종성: rawJong || '없음',
+        onset: rawCho === 'ㅇ' ? NONE : rawCho,
+        glide: VOWEL_GLIDE[rawJung] ?? NONE,
+        vowel: VOWEL_NUCLEUS[rawJung] ?? rawJung,
+        coda: rawJong || NONE,
     };
 }
 function analyzeMinimalPair(word1, word2, phonemic = false) {
@@ -94,8 +99,8 @@ function diffHasEmptyPair(section, vals) {
     // '활음' 섹션의 '없음'은 비움으로 보지 않는다 — 발음 모드에서 사용자가 활음 자리를 **직접 골라** 찾는 대립(ㅐ↔ㅙ = 없음↔w)이라
     // 그 검색 결과를 이 필터가 통째로 지우면 안 된다.
     const isEmpty = (v) => v === '' ||
-        (section === '종성' && v === '없음') ||
-        (section === '초성' && (v === 'ㅇ' || v === '없음'));
+        (section === 'coda' && v === NONE) ||
+        (section === 'onset' && (v === 'ㅇ' || v === NONE));
     if (isEmpty(vals[0]) || isEmpty(vals[1]))
         return true;
     // 모음(글자 모드) 활음 구조 차이: 두 모음의 반모음(활음)이 다르면 음절 '구조' 차이로 본다.
@@ -104,7 +109,7 @@ function diffHasEmptyPair(section, vals) {
     //  발음 모드는 모음=핵모음이라 둘 다 활음 없음으로 읽혀 영향 없음. 활음 대립은
     //  별도 '활음' 섹션에서 처리되므로 여기(모음)에서 걸러도 활음 지정 대립과 충돌하지 않는다.
     //  단어훈련 런타임(wordContrast.hasStructureContrast)도 **같은 함수**로 판정한다.
-    if (section === '모음' && vowelGlidesDiffer(vals[0], vals[1]))
+    if (section === 'vowel' && vowelGlidesDiffer(vals[0], vals[1]))
         return true;
     return false;
 }
@@ -122,29 +127,31 @@ const DEFAULT_PAIR_FILTER_KEYS = {
     syllable5plus: '5음절 이상',
     partOfSpeech: '품사',
     wordType: '유형',
+    field: '의미범주',
     posMap: POS_GROUP_MAP_KO,
     typeMap: WORD_TYPE_MAP_KO,
 };
-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 };
+const collected = new WeakMap();
+function collect(filterSelected, keys) {
+    const hit = collected.get(filterSelected);
+    if (hit && hit.keys === keys)
+        return hit.value;
+    const value = { grades: [], syls: [], poses: [], types: [], fields: [] };
+    const bySection = { grade: value.grades, syllables: value.syls, pos: value.poses, wordType: value.types, field: value.fields };
     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);
+                : label === keys.field ? 'field'
+                    : wordAttributeSectionOf(label);
         if (!s)
             continue;
         for (const v of Array.isArray(raw) ? raw : typeof raw === 'string' ? [raw] : [])
-            if (!칸[s].includes(v))
-                칸[s].push(v);
+            if (!bySection[s].includes(v))
+                bySection[s].push(v);
     }
-    모은것.set(filterSelected, { keys, 값 });
-    return 값;
+    collected.set(filterSelected, { keys, value });
+    return value;
 }
 /**
  * 난이도/음절수/품사/유형 필터를 단어 하나에 대해 판정(의미범주 제외 — WordEntry 전용이라 applyFilters에서 별도 처리).
@@ -154,7 +161,7 @@ function 모으기(filterSelected, keys) {
  * **풀리고** 품사·어종 값은 posMap 에 없어 **모든 단어가 떨어졌다**.
  */
 export function matchesFilters(word, filterSelected, keys = DEFAULT_PAIR_FILTER_KEYS) {
-    const { grades, syls, poses, types } = 모으기(filterSelected, keys);
+    const { grades, syls, poses, types } = collect(filterSelected, keys);
     if (grades.length) {
         /* **`없음` 은 값이 아니라 빔이다**((205), 2026-10-12) — 거르는 결정은 `matchesGradeCodes` **하나**다
            (단어훈련 풀도 같은 것을 부른다). 여기서는 라벨을 코드로만 바꾼다.
@@ -188,8 +195,14 @@ export function applyFilters(filterSelected, words, keys = DEFAULT_PAIR_FILTER_K
     return words.filter(entry => {
         if (!matchesFilters({ grade: entry.grade, syllables: [...entry.word].length, pos: entry.pos, wordType: entry.wordType }, filterSelected, keys))
             return false;
-        const fields = filterSelected['의미범주'];
-        if (fields?.length) {
+        /* **의미범주도 다른 넷과 같은 길로 읽는다**(사장님 지시 2026-10-14, 말귀 실측으로 다리는
+           필요 없음이 확인됐다 — 앱 소스 0건·저장 구성 416줄 0건).
+    
+           전에는 `filterSelected['의미범주']` 로 **그 다섯 글자만** 찾았다. 다른 절은 어느 언어
+           라벨이든 읽는데 이 하나만 안 그랬고, 영어 라벨로 부르면 **이 필터만 조용히 안 걸렸다**
+           (에러도 없다). 같은 꼴을 등급·음절에서 이미 겪어 고쳤던 자리다. */
+        const { fields } = collect(filterSelected, keys);
+        if (fields.length) {
             const normalized = (entry.field ?? '').replace(/전문\(|\)/g, '');
             if (!fields.some(f => normalized.includes(f)))
                 return false;
@@ -278,9 +291,15 @@ function searchPairsCore(selectedList, words, debug, enforcePosition, phonemic =
     const uniqueWordsCount = new Set(words.map(w => w.word)).size;
     const bySection = {};
     const bySectionValueOrder = {};
-    for (let i = 0; i < selectedList.length; i++) {
-        for (const [section, value] of Object.entries(selectedList[i])) {
-            if (!isSectionKey(section))
+    /* **들어오는 자리에서 한 번 옮긴다** — 저장된 단어표의 `phonemeSelected` 는 옛 한글 열쇠일
+       수 있다(`{ 초성: 'ㄴ' }`). 안쪽은 코드만 보므로 여기서 가른다. */
+    const codedList = selectedList.map(toCodes);
+    for (let i = 0; i < codedList.length; i++) {
+        for (const [section, value] of Object.entries(codedList[i])) {
+            /* **`!value` 로 거르지 않는다.** `{ 종성: '' }` 은 "받침 없음을 골랐다" 는 뜻이고,
+               옮기며 그 줄을 더했다가 `받침 있음↔없음` 검색이 빈손이 됐다(2026-10-13, 시험이 잡았다).
+               *옮기기에 거르는 줄을 끼워 넣으면 뜻이 바뀐다.* */
+            if (!isSectionKey(section) || value === undefined)
                 continue;
             if (!bySection[section])
                 bySection[section] = new Set();
@@ -315,16 +334,16 @@ function searchPairsCore(selectedList, words, debug, enforcePosition, phonemic =
     const targetKeys = new Set(sectionEntries.map(([s]) => s));
     const contrastSections = new Set(sectionEntries.filter(([, vals]) => vals.size >= 2).map(([s]) => s));
     const encodeAll = phonemic
-        ? (s) => s.초성 + (s.활음 ?? '') + s.모음 + s.종성
-        : (s) => s.초성 + s.모음 + s.종성;
+        ? (s) => s.onset + (s.glide ?? '') + s.vowel + s.coda
+        : (s) => s.onset + s.vowel + s.coda;
     const encodeWild = phonemic
-        ? (s) => (targetKeys.has('초성') ? '*' : s.초성) +
-            (targetKeys.has('활음') ? '*' : (s.활음 ?? '')) +
-            (targetKeys.has('모음') ? '*' : s.모음) +
-            (targetKeys.has('종성') ? '*' : s.종성)
-        : (s) => (targetKeys.has('초성') ? '*' : s.초성) +
-            (targetKeys.has('모음') ? '*' : s.모음) +
-            (targetKeys.has('종성') ? '*' : s.종성);
+        ? (s) => (targetKeys.has('onset') ? '*' : s.onset) +
+            (targetKeys.has('glide') ? '*' : (s.glide ?? '')) +
+            (targetKeys.has('vowel') ? '*' : s.vowel) +
+            (targetKeys.has('coda') ? '*' : s.coda)
+        : (s) => (targetKeys.has('onset') ? '*' : s.onset) +
+            (targetKeys.has('vowel') ? '*' : s.vowel) +
+            (targetKeys.has('coda') ? '*' : s.coda);
     const makeKeyForPosition = (syllables, diffPos) => syllables.map((s, i) => (i === diffPos ? encodeWild(s) : encodeAll(s))).join('|');
     const gradeOrder = (g) => {
         const parsed = Number.parseInt(g ?? '', 10);
@@ -335,9 +354,9 @@ function searchPairsCore(selectedList, words, debug, enforcePosition, phonemic =
        한 묶음의 낱말은 모두 같은 자리를 비운 것이다. 분해한 음절도 함께 든다(견줄 때마다 다시 분해하지 않게). */
     const groups = new Map();
     /* 표기가 같아도 뜻마다 칸이 하나다 — 판정은 대표로 한 번만 하고 결과에서 뜻을 펼친다 */
-    const { 대표들, 뜻들 } = 뜻묶기(words);
+    const { heads, senses } = groupBySense(words);
     const seenWords = new Set();
-    for (const entry of 대표들) {
+    for (const entry of heads) {
         seenWords.add(entry.word);
         const decomposeFn = phonemic ? decomposePhonemicSyllable : decompose;
         const syllables = [...cleanPron(entry.pronunciation)].map(decomposeFn);
@@ -346,25 +365,25 @@ function searchPairsCore(selectedList, words, debug, enforcePosition, phonemic =
         const syls = syllables;
         for (let p = 0; p < syls.length; p++) {
             const key = makeKeyForPosition(syls, p);
-            let 묶음 = groups.get(key);
-            if (!묶음) {
-                묶음 = { 비운자리: p, 낱말들: [] };
-                groups.set(key, 묶음);
+            let group = groups.get(key);
+            if (!group) {
+                group = { emptyAt: p, members: [] };
+                groups.set(key, group);
             }
-            묶음.낱말들.push({ entry, syls });
+            group.members.push({ entry, syls });
         }
     }
     const results = [];
     const rejectCounts = createRejectCounter();
     const rejectSamples = [];
     let comparedPairs = 0;
-    for (const { 비운자리, 낱말들 } of groups.values()) {
-        if (낱말들.length < 2)
+    for (const { emptyAt, members } of groups.values()) {
+        if (members.length < 2)
             continue;
-        for (let i = 0; i < 낱말들.length; i++) {
-            for (let j = i + 1; j < 낱말들.length; j++) {
-                const w1 = 낱말들[i].entry;
-                const w2 = 낱말들[j].entry;
+        for (let i = 0; i < members.length; i++) {
+            for (let j = i + 1; j < members.length; j++) {
+                const w1 = members[i].entry;
+                const w2 = members[j].entry;
                 /* 같은 표기가 발음만 다르게 두 번 들어온 자료(김밥[김밥]·김밥[김빱])는 짝으로 세지 않는다 —
                    칸 둘의 이름이 같은 '김밥/김밥' 쌍이 된다. 견준 쌍을 다 기억하던 전에는 이것이
                    덤으로 막히고 있었다(같은 표기면 열쇠가 하나라 한 번만 지나갔다). */
@@ -383,15 +402,15 @@ function searchPairsCore(selectedList, words, debug, enforcePosition, phonemic =
                    남은 것은 '한 군데만 다른가' 를 쌍 문자열·발음 분해 전에 여기서 재는 일이다 —
                    analyzeMinimalPair 와 같은 잣대(SECTION_KEYS)를 그 한 자리에만 쓴다. 포함 검색
                    (searchWordsByPhonemes)이 전부터 하던 것과 같은 걸름이다. */
-                const s1 = 낱말들[i].syls[비운자리];
-                const s2 = 낱말들[j].syls[비운자리];
-                let 다른칸수 = 0;
+                const s1 = members[i].syls[emptyAt];
+                const s2 = members[j].syls[emptyAt];
+                let diffCount = 0;
                 for (const sec of SECTION_KEYS)
                     if (s1[sec] !== s2[sec])
-                        다른칸수 += 1;
+                        diffCount += 1;
                 comparedPairs += 1;
-                if (다른칸수 !== 1) {
-                    const reason = 다른칸수 === 0 ? 'no_difference' : 'multiple_differences';
+                if (diffCount !== 1) {
+                    const reason = diffCount === 0 ? 'no_difference' : 'multiple_differences';
                     rejectCounts[reason] += 1;
                     if (debug && rejectSamples.length < 20)
                         rejectSamples.push({ id: `${w1.word}|${w2.word}`, reason });
@@ -421,13 +440,15 @@ function searchPairsCore(selectedList, words, debug, enforcePosition, phonemic =
                 const sDiffVals = analysis.diff.diffs[sDiffSection];
                 const sDiffHasEmpty = diffHasEmptyPair(sDiffSection, sDiffVals);
                 // 뜻마다 한 칸 — '눈'(신체)·'눈'(날씨) 가 각각 '문' 과 쌍을 이룬다
-                for (const f of 뜻들.get(first) ?? [first]) {
-                    for (const sec of 뜻들.get(second) ?? [second]) {
+                for (const f of senses.get(first) ?? [first]) {
+                    for (const sec of senses.get(second) ?? [second]) {
                         results.push({
-                            id: `${낱말열쇠(f)}|${낱말열쇠(sec)}`,
-                            diffSection: sDiffSection,
+                            id: `${wordKey(f)}|${wordKey(sec)}`,
+                            /* 옛 이름을 내보내고 코드를 나란히 — 소비자가 옛 값으로 묶음을 가른다 */
+                            diffSection: toLegacyPhonemeKey(sDiffSection),
+                            diffSectionCode: sDiffSection,
                             diffHasEmpty: sDiffHasEmpty,
-                            words: [낱말칸(f), 낱말칸(sec)],
+                            words: [wordCells(f), wordCells(sec)],
                         });
                     }
                 }
@@ -469,38 +490,38 @@ export function searchPairs(selectedList, words, enforcePosition, phonemic = fal
 // 슬롯 i → 단어의 i번째 음절에 조건 매칭 (순서 보장)
 /** 표기가 같아도 뜻이 다르면 다른 칸 — 칸에 붙는 그림이 뜻마다 다르다(사용자 결정 2026-09-16).
  *  동음이의 번호가 없는 자료는 예전처럼 표기뿐이다. */
-function 낱말열쇠(entry) {
+function wordKey(entry) {
     return entry.homonum != null ? `${entry.word}#${entry.homonum}` : entry.word;
 }
 /** 표기·발음이 같은 뜻들을 한 대표로 묶는다 — 최소대립쌍 판정은 표기와 발음만 보므로 뜻마다 다시 셀 까닭이 없다.
  *  (뜻을 모두 후보로 넣으면 묶음이 커져 23,000 낱말에서 검색이 2–4배 느려졌다.) 결과를 만들 때 뜻마다 칸을 펼친다. */
 /** 결과 칸 하나 */
-function 낱말칸(e) {
+function wordCells(e) {
     return {
         label: e.word, subLabel: e.pronunciation, colloquialLabel: e.colloquialPronunciation, homonum: e.homonum,
         grade: e.grade, syllables: [...e.word].length, pos: e.pos, wordType: e.wordType, isCustom: e.isCustom,
     };
 }
-function 뜻묶기(words) {
-    const 자리 = new Map();
-    const 뜻들 = new Map();
-    const 대표들 = [];
+function groupBySense(words) {
+    const byKey = new Map();
+    const senses = new Map();
+    const heads = [];
     for (const entry of words) {
-        const 열쇠 = `${entry.word}\u0000${cleanPron(entry.pronunciation)}`;
-        const 대표 = 자리.get(열쇠);
-        if (대표 === undefined) {
-            자리.set(열쇠, entry);
-            대표들.push(entry);
-            뜻들.set(entry, [entry]);
+        const key = `${entry.word}\u0000${cleanPron(entry.pronunciation)}`;
+        const head = byKey.get(key);
+        if (head === undefined) {
+            byKey.set(key, entry);
+            heads.push(entry);
+            senses.set(entry, [entry]);
             continue;
         }
-        const 목록 = 뜻들.get(대표);
+        const list = senses.get(head);
         // 같은 번호가 두 번 오면(자료 중복) 한 번만
-        if (목록.some(e => 낱말열쇠(e) === 낱말열쇠(entry)))
+        if (list.some(e => wordKey(e) === wordKey(entry)))
             continue;
-        목록.push(entry);
+        list.push(entry);
     }
-    return { 대표들, 뜻들 };
+    return { heads, senses };
 }
 function wordContainsAllPhonemes(syllables, requirements) {
     for (let i = 0; i < requirements.length; i++) {
@@ -534,18 +555,20 @@ export function searchWordsByPhonemes(requiredPhonemes, words, ordered = true, p
  *  이 조건을 만족하는 쪽을 우선한다(예: "검색 단어만" 필터 통과 여부). 지정하지
  *  않으면 기존 동작(먼저 발견된 방향을 그대로 채택)과 동일하다. */
 preferAsTarget) {
-    const reqs = requiredPhonemes.filter(r => Object.keys(r).some(k => isSectionKey(k)));
+    /* 들어오는 자리에서 코드로 — 옛 한글 열쇠로 저장된 표도 그대로 읽힌다 */
+    const coded = requiredPhonemes.map(toCodes);
+    const reqs = coded.filter(r => Object.keys(r).some(k => isSectionKey(k)));
     if (reqs.length === 0)
         return [];
     const encodeAll = phonemic
-        ? (s) => s.초성 + (s.활음 ?? '') + s.모음 + s.종성
-        : (s) => s.초성 + s.모음 + s.종성;
+        ? (s) => s.onset + (s.glide ?? '') + s.vowel + s.coda
+        : (s) => s.onset + s.vowel + s.coda;
     const makeKey = (syls, pos) => syls.map((s, i) => (i === pos ? '*' : encodeAll(s))).join('|');
     const decomposeFn = phonemic ? decomposePhonemicSyllable : decompose;
     const allWords = [];
-    const { 대표들, 뜻들 } = 뜻묶기(words);
+    const { heads, senses } = groupBySense(words);
     const seenWords = new Set();
-    for (const entry of 대표들) {
+    for (const entry of heads) {
         seenWords.add(entry.word);
         const syls = [...cleanPron(entry.pronunciation)].map(decomposeFn);
         if (syls.some(s => s === null))
@@ -563,7 +586,7 @@ preferAsTarget) {
         /* 일치(ordered) 는 조건의 자리가 곧 음절 자리다 — 빈 슬롯을 걸러 낸 reqs 를 쓰면 [{}, {초성:ㄴ}] 의 ㄴ 이 첫 음절에 걸렸다.
            wordContainsAllPhonemes 는 빈 슬롯을 스스로 건너뛴다. */
         return ordered
-            ? wordContainsAllPhonemes(filterSyls, requiredPhonemes)
+            ? wordContainsAllPhonemes(filterSyls, coded)
             : wordContainsAllPhonemesUnordered(filterSyls, reqs);
     });
     const groups = new Map();
@@ -575,7 +598,7 @@ preferAsTarget) {
             groups.get(key).push(w);
         }
     }
-    const 쌍들 = [];
+    const pairs = [];
     // dedupKey → 쌍들 배열 내 인덱스. 같은 두 단어가 서로 minimal pair이면서
     // 둘 다 독립적으로 targetWords에 속할 수 있어(예: 다른 음절에 요구 음소가 하나 더 있는 경우),
     // 어느 쪽을 target(1번/words[0])으로 채택할지가 순회 순서에 좌우될 수 있다.
@@ -594,13 +617,13 @@ preferAsTarget) {
                 {
                     const cs = candidate.syls[p];
                     let d = 0;
-                    if (ts.초성 !== cs.초성)
+                    if (ts.onset !== cs.onset)
                         d++;
-                    if (ts.모음 !== cs.모음)
+                    if (ts.vowel !== cs.vowel)
                         d++;
-                    if (ts.종성 !== cs.종성)
+                    if (ts.coda !== cs.coda)
                         d++;
-                    if ((ts.활음 ?? '') !== (cs.활음 ?? ''))
+                    if ((ts.glide ?? '') !== (cs.glide ?? ''))
                         d++;
                     if (d !== 1)
                         continue;
@@ -612,7 +635,7 @@ preferAsTarget) {
                 if (existingIdx !== undefined) {
                     if (!preferAsTarget)
                         continue;
-                    if (preferAsTarget(낱말칸(쌍들[existingIdx].target)))
+                    if (preferAsTarget(wordCells(pairs[existingIdx].target)))
                         continue;
                     if (!preferAsTarget({ grade: target.entry.grade, syllables: [...target.entry.word].length, pos: target.entry.pos, wordType: target.entry.wordType }))
                         continue;
@@ -635,12 +658,12 @@ preferAsTarget) {
                         if (tv !== cv)
                             diffValues = [tv, cv];
                     }
-                    const 맞나 = (req) => {
+                    const matches = (req) => {
                         const reqVal = req?.[diffSection];
                         return reqVal !== undefined && (diffValues[0] === reqVal || diffValues[1] === reqVal);
                     };
                     // 일치(ordered): "첫번째 음절에서 초성 ㄱ 이 대립" — 대립한 자리의 조건이어야 한다(다른 음절에서 대립한 쌍이 섞였다)
-                    const isRelevant = ordered ? 맞나(requiredPhonemes[analysis.diff.idx]) : reqs.some(맞나);
+                    const isRelevant = ordered ? matches(coded[analysis.diff.idx]) : reqs.some(matches);
                     if (!isRelevant)
                         continue;
                 }
@@ -649,26 +672,27 @@ preferAsTarget) {
                 const diffHasEmpty = diffHasEmptyPair(diffSection, diffVals);
                 const item = { target: target.entry, candidate: candidate.entry, diffSection, diffHasEmpty };
                 if (existingIdx !== undefined) {
-                    쌍들[existingIdx] = item;
+                    pairs[existingIdx] = item;
                 }
                 else {
-                    seenPairs.set(dedupKey, 쌍들.length);
-                    쌍들.push(item);
+                    seenPairs.set(dedupKey, pairs.length);
+                    pairs.push(item);
                 }
             }
         }
     }
     /* 뜻마다 한 칸 — 기준·짝의 뜻을 모두 펼친다('눈'(신체)·'눈'(날씨) 가 각각 '문' 과 쌍). id 는 정렬 꼴에 번호까지. */
     const results = [];
-    for (const 것 of 쌍들) {
-        for (const t of 뜻들.get(것.target) ?? [것.target]) {
-            for (const c of 뜻들.get(것.candidate) ?? [것.candidate]) {
-                const kt = 낱말열쇠(t), kc = 낱말열쇠(c);
+    for (const item of pairs) {
+        for (const t of senses.get(item.target) ?? [item.target]) {
+            for (const c of senses.get(item.candidate) ?? [item.candidate]) {
+                const kt = wordKey(t), kc = wordKey(c);
                 results.push({
                     id: kt < kc ? `${kt}|${kc}` : `${kc}|${kt}`,
-                    diffSection: 것.diffSection,
-                    diffHasEmpty: 것.diffHasEmpty,
-                    words: [낱말칸(t), 낱말칸(c)],
+                    diffSection: toLegacyPhonemeKey(item.diffSection),
+                    diffSectionCode: item.diffSection,
+                    diffHasEmpty: item.diffHasEmpty,
+                    words: [wordCells(t), wordCells(c)],
                 });
             }
         }

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

@@ -25,6 +25,8 @@ export interface PairFilterKeys {
     syllable5plus: string;
     partOfSpeech: string;
     wordType: string;
+    /** 의미범주 절의 이름표. **안 줘도 된다** — 안 주면 어느 언어 라벨이든 사전으로 읽는다(0.324.0). */
+    field?: string;
     posMap: Record<string, string[]>;
     typeMap: Record<string, string>;
 }

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

@@ -0,0 +1,52 @@
+/**
+ * **음절 자리의 코드** — `onset`·`vowel`·`coda`·`glide`, 그리고 빔(`none`).
+ *
+ * ## 왜 제 모듈인가
+ *
+ * 처음에는 이 가름을 `phonemePairSearch` 에 두고 `phonemeConvert` 가 들여왔다 — 그런데
+ * `phonemePairSearch` 도 `phonemeConvert`(`VOWEL_TO_PHONEME`)를 들여온다. **돌림 import** 가
+ * 되어 시험 **338 꾸러미**가 한꺼번에 무너졌다(2026-10-13). 두 쪽이 함께 쓰는 것은 **어느
+ * 한쪽이 아니라 그 아래**에 둔다.
+ *
+ * ## 왜 코드인가
+ *
+ * 전에는 열쇠가 한글(`'초성'`)이었고 그것이 **저장된다** — 단어표의
+ * `searchConfig.phonemeSelected` 가 그 꼴이다. 저장되는 값이 표시 언어에 묶이면 말을 고치려
+ * 해도 자료를 밀어야 한다(사장님 지시 2026-10-13 "동작에 한글이 끼지 말라").
+ *
+ * **값을 바꾸지 않고 읽는 쪽을 너그럽게 했다** — 표준의 *lenient reader · strict writer*.
+ * 저장된 표를 밀지 않아도 되고 소비자 코드도 안 바뀐다. 안쪽 로직에서만 한글이 사라진다.
+ *
+ * 어휘는 **훈련 필터가 이미 쓰던 것**과 같게 뒀다(`useWordTrainingFilter` 의 `onset`·`vowel`·
+ * `coda`) — 같은 뜻에 어휘가 둘이던 것을 모았다.
+ *
+ * **값(자모 `'ㄴ'`)은 그대로다** — 그것은 한국어 글자 그 자체이고 바꿀 것은 열쇠와 빔 값이다.
+ */
+/** 음절 자리 코드 @public */
+export type PhonemeSectionCode = 'onset' | 'vowel' | 'coda' | 'glide';
+/** @public */
+export declare const PHONEME_SECTION_CODES: PhonemeSectionCode[];
+/** 자리가 비었음 — 초성 ㅇ · 받침 없음 · 활음 없음을 한 값으로 적는다 @public */
+export declare const PHONEME_NONE = "none";
+/** @public */
+export declare function isPhonemeSectionCode(value: string): value is PhonemeSectionCode;
+/**
+ * **들어오는 고른값 하나를 코드 꼴로.** 옛 한글 열쇠·옛 빔 값도 받는다.
+ *
+ * 공개 함수(`searchPairs`·`searchWordsByPhonemes`·`convertToPhoneme`)가 받는
+ * `Record<string, string>` 은 **저장된 검색 구성에서 온다** — 그 꼴을 바꾸면 이미 저장된
+ * 단어표가 깨진다. 그래서 들어오는 자리에서 한 번 옮기고, 안쪽은 코드만 본다.
+ *
+ * @public
+ */
+export declare function toPhonemeCodes(sel: Record<string, string>): Partial<Record<PhonemeSectionCode, string>>;
+/**
+ * 코드를 **옛 열쇠 글자로** — 밖으로 나가는 `diffSection` 이 그 꼴이다.
+ *
+ * 소비자가 그 값으로 묶음을 가른다(말귀 `WordPairsPage` 의 `GROUP_ORDER`·`GROUP_LABEL`).
+ * 혼자 코드로 바꾸면 **그쪽 묶음이 조용히 빈다** — 그래서 옛 이름을 내보내고, 코드는
+ * `diffSectionCode` 로 **나란히** 둔다(2026-10-13). 소비자가 옮긴 뒤 옛 쪽을 걷는다.
+ *
+ * @public
+ */
+export declare function toLegacyPhonemeKey(code: PhonemeSectionCode): string;

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

@@ -0,0 +1,76 @@
+/**
+ * **음절 자리의 코드** — `onset`·`vowel`·`coda`·`glide`, 그리고 빔(`none`).
+ *
+ * ## 왜 제 모듈인가
+ *
+ * 처음에는 이 가름을 `phonemePairSearch` 에 두고 `phonemeConvert` 가 들여왔다 — 그런데
+ * `phonemePairSearch` 도 `phonemeConvert`(`VOWEL_TO_PHONEME`)를 들여온다. **돌림 import** 가
+ * 되어 시험 **338 꾸러미**가 한꺼번에 무너졌다(2026-10-13). 두 쪽이 함께 쓰는 것은 **어느
+ * 한쪽이 아니라 그 아래**에 둔다.
+ *
+ * ## 왜 코드인가
+ *
+ * 전에는 열쇠가 한글(`'초성'`)이었고 그것이 **저장된다** — 단어표의
+ * `searchConfig.phonemeSelected` 가 그 꼴이다. 저장되는 값이 표시 언어에 묶이면 말을 고치려
+ * 해도 자료를 밀어야 한다(사장님 지시 2026-10-13 "동작에 한글이 끼지 말라").
+ *
+ * **값을 바꾸지 않고 읽는 쪽을 너그럽게 했다** — 표준의 *lenient reader · strict writer*.
+ * 저장된 표를 밀지 않아도 되고 소비자 코드도 안 바뀐다. 안쪽 로직에서만 한글이 사라진다.
+ *
+ * 어휘는 **훈련 필터가 이미 쓰던 것**과 같게 뒀다(`useWordTrainingFilter` 의 `onset`·`vowel`·
+ * `coda`) — 같은 뜻에 어휘가 둘이던 것을 모았다.
+ *
+ * **값(자모 `'ㄴ'`)은 그대로다** — 그것은 한국어 글자 그 자체이고 바꿀 것은 열쇠와 빔 값이다.
+ */
+/** @public */
+export const PHONEME_SECTION_CODES = ['onset', 'vowel', 'coda', 'glide'];
+/** 자리가 비었음 — 초성 ㅇ · 받침 없음 · 활음 없음을 한 값으로 적는다 @public */
+export const PHONEME_NONE = 'none';
+/** 저장된 옛 열쇠 → 코드. 옛 표를 읽을 때만 쓰는 다리다(새로 쓰는 것은 코드뿐) */
+const LEGACY_SECTION_KEY = {
+    초성: 'onset', 모음: 'vowel', 종성: 'coda', 활음: 'glide',
+};
+/** 저장된 옛 '빔' 값 */
+const LEGACY_NONE = '없음';
+/** @public */
+export function isPhonemeSectionCode(value) {
+    return PHONEME_SECTION_CODES.includes(value);
+}
+/**
+ * **들어오는 고른값 하나를 코드 꼴로.** 옛 한글 열쇠·옛 빔 값도 받는다.
+ *
+ * 공개 함수(`searchPairs`·`searchWordsByPhonemes`·`convertToPhoneme`)가 받는
+ * `Record<string, string>` 은 **저장된 검색 구성에서 온다** — 그 꼴을 바꾸면 이미 저장된
+ * 단어표가 깨진다. 그래서 들어오는 자리에서 한 번 옮기고, 안쪽은 코드만 본다.
+ *
+ * @public
+ */
+export function toPhonemeCodes(sel) {
+    const out = {};
+    for (const [k, v] of Object.entries(sel)) {
+        const key = isPhonemeSectionCode(k) ? k : LEGACY_SECTION_KEY[k];
+        /* **빈 값은 버리지 않는다.** `{ 종성: '' }` 은 "받침 없음을 골랐다" 는 **뜻 있는 고름**이다 —
+           한 번 버렸다가 `받침 있음↔없음` 대립 검색이 빈손이 됐다(2026-10-13, 시험이 잡았다).
+           거르는 것은 **열쇠를 못 알아볼 때**뿐이다. */
+        if (!key)
+            continue;
+        out[key] = v === LEGACY_NONE ? PHONEME_NONE : v;
+    }
+    return out;
+}
+/** 코드 → 저장된 옛 열쇠. 밖으로 내보내는 값이 옛 꼴이어야 할 때만 쓴다 */
+const CODE_TO_LEGACY = {
+    onset: '초성', vowel: '모음', coda: '종성', glide: '활음',
+};
+/**
+ * 코드를 **옛 열쇠 글자로** — 밖으로 나가는 `diffSection` 이 그 꼴이다.
+ *
+ * 소비자가 그 값으로 묶음을 가른다(말귀 `WordPairsPage` 의 `GROUP_ORDER`·`GROUP_LABEL`).
+ * 혼자 코드로 바꾸면 **그쪽 묶음이 조용히 빈다** — 그래서 옛 이름을 내보내고, 코드는
+ * `diffSectionCode` 로 **나란히** 둔다(2026-10-13). 소비자가 옮긴 뒤 옛 쪽을 걷는다.
+ *
+ * @public
+ */
+export function toLegacyPhonemeKey(code) {
+    return CODE_TO_LEGACY[code];
+}

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

@@ -26,19 +26,19 @@
  * @public
  */
 export function prefetchChunk(...loads) {
-    let 취소됨 = false;
-    const 받기 = () => { if (!취소됨)
+    let cancelled = false;
+    const load = () => { if (!cancelled)
         for (const load of loads)
             void load().catch(() => { }); };
     const idle = globalThis.requestIdleCallback;
     if (idle) {
-        const id = idle(받기, { timeout: 2000 });
+        const id = idle(load, { timeout: 2000 });
         return () => {
-            취소됨 = true;
+            cancelled = true;
             const cancel = globalThis.cancelIdleCallback;
             cancel?.(id);
         };
     }
-    const id = setTimeout(받기, 300);
-    return () => { 취소됨 = true; clearTimeout(id); };
+    const id = setTimeout(load, 300);
+    return () => { cancelled = true; clearTimeout(id); };
 }

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

@@ -8,16 +8,16 @@
 export function isSafeOpenHref(href) {
     if (typeof href !== 'string')
         return false;
-    let 걷은 = '';
+    let stripped = '';
     for (const ch of href) {
         const c = ch.charCodeAt(0);
         if (c <= 0x20 || (c >= 0x7f && c <= 0x9f))
             continue;
-        걷은 += ch;
+        stripped += ch;
     }
-    if (!걷은)
+    if (!stripped)
         return false;
-    const m = /^([a-zA-Z][a-zA-Z0-9+.-]*):/.exec(걷은);
+    const m = /^([a-zA-Z][a-zA-Z0-9+.-]*):/.exec(stripped);
     if (!m)
         return true; // 스킴이 없다 — 상대 경로(`/help`·`./a`·`?q`·`#x`)·`//host` 는 지금 문서의 스킴을 따른다
     return ['http', 'https', 'mailto', 'tel'].includes(m[1].toLowerCase());