@ihabdevteam/core 0.322.0 → 0.324.0

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

@@ -110,6 +110,16 @@
             "금",
             "토"
         ],
+        "weekOrdinal": [
+            "첫째",
+            "둘째",
+            "셋째",
+            "넷째",
+            "다섯째",
+            "여섯째",
+            "일곱째"
+        ],
+        "weekLabel": "{{ord}}주",
         "yearMonth": "{{year}}년 {{month}}월",
         "prevMonth": "이전 달",
         "addOnDate": "{{date}}에 방문 등록",
@@ -899,6 +909,7 @@
                 "modifier": "수식언(부사, 관형사)"
             },
             "wordType": "유형",
+            "field": "의미범주",
             "type": {
                 "native": "고유어",
                 "sino": "한자어",
@@ -1048,7 +1059,8 @@
         "removeDevice": "착용 해제",
         "type": {
             "hearingAid": "보청기",
-            "cochlearImplant": "인공와우"
+            "cochlearImplant": "인공와우",
+            "other": "기타"
         }
     },
     "manager": {

package/dist/packages/core/src/types/wordSearch.d.ts

@@ -19,7 +19,16 @@ export interface WordSearchResultWord {
 export interface WordSearchResultItem {
     id: string;
     words: WordSearchResultWord[];
+    /**
+     * 갈린 자리 — **옛 한글 이름**(`'초성'`·`'모음'`·`'종성'`·`'활음'`)이다.
+     *
+     * @deprecated `diffSectionCode` 를 쓴다 — 같은 자리를 코드로 가리킨다. 2026-10-13 안쪽을
+     * 코드로 옮겼지만 **소비자가 이 값으로 묶음을 가른다**(말귀 `WordPairsPage` 의 `GROUP_ORDER`).
+     * 혼자 바꾸면 그쪽 묶음이 조용히 빈다. 소비자가 옮긴 뒤 걷는다.
+     */
     diffSection?: string;
+    /** 갈린 자리 — 코드(`'onset'`·`'vowel'`·`'coda'`·`'glide'`). 이쪽이 정본이다. */
+    diffSectionCode?: import('../utils/phonemeSectionCodes').PhonemeSectionCode;
     diffHasEmpty?: boolean;
 }
 /**

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

@@ -20,19 +20,19 @@ const _graphs = new WeakMap();
 const _desired = new WeakMap();
 const _pending = new WeakMap();
 let _unlockInstalled = false;
-const 자르기 = (v) => Math.max(0, Math.min(1, Number.isFinite(v) ? v : 0));
+const clamp01 = (v) => Math.max(0, Math.min(1, Number.isFinite(v) ? v : 0));
 /** 첫 사용자 제스처(및 이후 제스처)마다 멈춘 컨텍스트를 깨운다 — iOS 는 제스처 안에서만 resume 이 먹는다 */
 function installGestureUnlock() {
     if (_unlockInstalled || typeof document === 'undefined')
         return;
     _unlockInstalled = true;
-    const 깨우기 = () => { try {
+    const resumeCtx = () => { try {
         if (_ctx && _ctx.state !== 'running')
             void _ctx.resume();
     }
     catch { /* noop */ } };
     for (const type of ['pointerdown', 'touchend', 'keydown']) {
-        document.addEventListener(type, 깨우기, { capture: true, passive: true });
+        document.addEventListener(type, resumeCtx, { capture: true, passive: true });
     }
 }
 function getContext() {
@@ -68,7 +68,7 @@ function build(ctx, el) {
         analyser.fftSize = 1024;
         analyser.smoothingTimeConstant = 0.6;
         // 태우기 직전의 요소 볼륨을 gain 으로 옮기고 요소는 1 로 — 순서가 바뀌면 한 순간 두 번 곱해진다
-        gain.gain.value = 자르기(_desired.get(el) ?? el.volume);
+        gain.gain.value = clamp01(_desired.get(el) ?? el.volume);
         source.connect(gain);
         gain.connect(analyser);
         gain.connect(ctx.destination);
@@ -137,7 +137,7 @@ export function getElementAnalyser(el) {
  * 불러 램프를 만들어도 된다.
  */
 export function setElementVolume(el, volume) {
-    const v = 자르기(volume);
+    const v = clamp01(volume);
     _desired.set(el, v);
     const graph = _graphs.get(el);
     if (graph) {

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

@@ -6,4 +6,4 @@
  * 문장의 앞 무음은 진짜 그 소리의 일부이고, 앞뒤 뜸((74))이 그 위에서 셈된다.
  * @public
  */
-export declare function computePeaksFromUrl(url: string, bars: number, windowSeconds?: number, 앞무음건너뛰기?: boolean): Promise<number[] | null>;
+export declare function computePeaksFromUrl(url: string, bars: number, windowSeconds?: number, skipLeadingSilence?: boolean): Promise<number[] | null>;

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

@@ -26,10 +26,10 @@ import { getErrorMessage } from './errorMessage';
  *
  * 0.001 은 디더까지 잡고 0.02 는 진짜 작은 소리를 잘라 낸다 — 가운데를 쓴다.
  */
-const 무음기준 = 0.01;
+const SILENCE_LEVEL = 0.01;
 /** 아무리 조용한 파일이라도 이만큼 넘게는 안 건너뛴다 — 통째로 미끄러지지 않게 */
-const 건너뛰기한도초 = 0.3;
-async function decodeAndComputePeaks(arrayBuffer, bars, windowSeconds, 앞무음건너뛰기 = false) {
+const SKIP_LIMIT_SEC = 0.3;
+async function decodeAndComputePeaks(arrayBuffer, bars, windowSeconds, skipLeadingSilence = false) {
     /* 컨텍스트는 **어느 길로 나가든** 닫는다 — 디코딩 실패(404·만료 주소의 HTML)·채널 없음에서 닫지 않아
        파형 하나 실패할 때마다 AudioContext 가 하나씩 남았다(브라우저 동시 한도에 닿으면 이후 파형이 모두 실패). */
     let audioCtx = null;
@@ -42,24 +42,24 @@ async function decodeAndComputePeaks(arrayBuffer, bars, windowSeconds, 앞무음
             return null;
         /* **앞머리 무음을 건너뛴다**(소음처럼 루프되는 바탕에서만 켠다). 소리 있는 첫 자리를 찾아
            거기서부터 창을 연다 — 그래야 그린 결이 **실제로 들리는 결**이 된다. */
-        let 시작 = 0;
-        if (앞무음건너뛰기) {
-            const 한도 = Math.floor(건너뛰기한도초 * decoded.sampleRate);
-            const 끝 = Math.min(channelData.length, 한도);
-            while (시작 < 끝 && Math.abs(channelData[시작]) <= 무음기준)
-                시작++;
-            if (시작 >= 끝)
-                시작 = 0; // 통째로 조용한 파일 — 건너뛰지 않는다
+        let offset = 0;
+        if (skipLeadingSilence) {
+            const limit = Math.floor(SKIP_LIMIT_SEC * decoded.sampleRate);
+            const end = Math.min(channelData.length, limit);
+            while (offset < end && Math.abs(channelData[offset]) <= SILENCE_LEVEL)
+                offset++;
+            if (offset >= end)
+                offset = 0; // 통째로 조용한 파일 — 건너뛰지 않는다
         }
-        const 남은 = channelData.length - 시작;
+        const remaining = channelData.length - offset;
         const total = (windowSeconds && windowSeconds > 0)
-            ? Math.min(남은, Math.floor(windowSeconds * decoded.sampleRate))
-            : 남은;
+            ? Math.min(remaining, Math.floor(windowSeconds * decoded.sampleRate))
+            : remaining;
         const usableLen = Math.max(bars, total);
         const blockSize = Math.floor(usableLen / bars) || 1;
         const peaks = new Array(bars).fill(0).map((_, i) => {
-            const start = 시작 + i * blockSize;
-            const end = Math.min(start + blockSize, 시작 + usableLen, channelData.length);
+            const start = offset + i * blockSize;
+            const end = Math.min(start + blockSize, offset + usableLen, channelData.length);
             let max = 0;
             for (let j = start; j < end; j++) {
                 const v = Math.abs(channelData[j]);
@@ -89,14 +89,14 @@ async function decodeAndComputePeaks(arrayBuffer, bars, windowSeconds, 앞무음
  * 문장의 앞 무음은 진짜 그 소리의 일부이고, 앞뒤 뜸((74))이 그 위에서 셈된다.
  * @public
  */
-export async function computePeaksFromUrl(url, bars, windowSeconds, 앞무음건너뛰기 = false) {
+export async function computePeaksFromUrl(url, bars, windowSeconds, skipLeadingSilence = false) {
     try {
         const resp = await fetch(url);
         // 404·만료 주소는 소리가 아니다 — 디코딩까지 가지 않는다
         if (resp.ok === false)
             return null;
         const arrayBuffer = await resp.arrayBuffer();
-        return await decodeAndComputePeaks(arrayBuffer, bars, windowSeconds, 앞무음건너뛰기);
+        return await decodeAndComputePeaks(arrayBuffer, bars, windowSeconds, skipLeadingSilence);
     }
     catch (e) {
         try {

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

@@ -20,9 +20,9 @@ export function columnsFitting(width, cardWidth, gap) {
 export function balancedColumns(count, perRow) {
     if (!(count > 0))
         return 1;
-    const 한줄 = Math.max(1, Math.floor(perRow));
-    if (count <= 한줄)
+    const perRowInt = Math.max(1, Math.floor(perRow));
+    if (count <= perRowInt)
         return count;
-    const 줄수 = Math.ceil(count / 한줄);
-    return Math.max(1, Math.ceil(count / 줄수));
+    const rowCount = Math.ceil(count / perRowInt);
+    return Math.max(1, Math.ceil(count / rowCount));
 }

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

@@ -31,7 +31,7 @@
 const SKEW_KEY = 'chunk-reload-ts';
 /** 이 시간 안에 다시 실패하면 배포 skew 가 아니라 진짜 오류로 본다(무한 새로고침 방지). */
 const COOLDOWN_MS = 10_000;
-function 마지막시각() {
+function lastAt() {
     try {
         return Number(sessionStorage.getItem(SKEW_KEY) || 0);
     }
@@ -48,7 +48,7 @@ function 마지막시각() {
  * @public
  */
 export function recoverFromSkew(now = Date.now()) {
-    if (now - 마지막시각() <= COOLDOWN_MS)
+    if (now - lastAt() <= COOLDOWN_MS)
         return false;
     try {
         sessionStorage.setItem(SKEW_KEY, String(now));
@@ -65,7 +65,7 @@ export function recoverFromSkew(now = Date.now()) {
  * 무엇을 그릴지 정하는 데 쓴다 — **아무것도 안 그리는 것이 맞다.** 곧 판이 바뀐다.
  */
 export function skewReloadPending(now = Date.now()) {
-    const last = 마지막시각();
+    const last = lastAt();
     return last > 0 && now - last <= COOLDOWN_MS;
 }
 /**
@@ -97,18 +97,18 @@ export function skewReloadPending(now = Date.now()) {
 export function installSkewRecovery() {
     if (typeof window === 'undefined')
         return () => { };
-    const 청크실패 = (e) => { if (recoverFromSkew())
+    const onChunkError = (e) => { if (recoverFromSkew())
         e.preventDefault(); };
     /* 스타일시트만 본다 — 그림 하나가 깨졌다고 판을 새로 받으면 안 된다 */
-    const 스타일실패 = (e) => {
+    const onStyleError = (e) => {
         const el = e.target;
         if (el instanceof HTMLLinkElement && el.rel === 'stylesheet')
             recoverFromSkew();
     };
-    window.addEventListener('vite:preloadError', 청크실패);
-    window.addEventListener('error', 스타일실패, true);
+    window.addEventListener('vite:preloadError', onChunkError);
+    window.addEventListener('error', onStyleError, true);
     return () => {
-        window.removeEventListener('vite:preloadError', 청크실패);
-        window.removeEventListener('error', 스타일실패, true);
+        window.removeEventListener('vite:preloadError', onChunkError);
+        window.removeEventListener('error', onStyleError, true);
     };
 }

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

@@ -12,7 +12,7 @@ export async function copyText(text) {
     if (typeof document !== 'undefined') {
         // 숨긴 textarea 에 포커스를 옮기므로, 끝나면 원래 자리로 돌려준다 — 안 돌리면 복사 단추를
         // 누른 뒤 키보드 포커스가 body 로 떨어져 스크린리더·Tab 이동이 처음부터 다시 시작된다.
-        const 원래포커스 = document.activeElement;
+        const previousFocus = document.activeElement;
         let ta = null;
         try {
             ta = document.createElement('textarea');
@@ -38,9 +38,9 @@ export async function copyText(text) {
             // 성공·실패·던짐 어느 길이든 textarea 를 거두고 포커스를 되돌린다
             if (ta?.parentNode)
                 ta.parentNode.removeChild(ta);
-            if (원래포커스 && 원래포커스 !== document.activeElement && typeof 원래포커스.focus === 'function' && 원래포커스.isConnected) {
+            if (previousFocus && previousFocus !== document.activeElement && typeof previousFocus.focus === 'function' && previousFocus.isConnected) {
                 try {
-                    원래포커스.focus({ preventScroll: true });
+                    previousFocus.focus({ preventScroll: true });
                 }
                 catch { /* 무시 */ }
             }

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

@@ -26,12 +26,12 @@ function mulberry32(seed) {
 // shuffle/sample은 공용 utils/array로 통일(시드 rng 지원 동일). 여기선 sampleArray 이름만 유지해 내부에서 사용.
 const sampleArray = sample;
 /** KST 날짜 'YYYY-MM-DD' → 날 번호(1970-01-01 = 0). 홀짝으로 이틀마다 번갈아 쓸 반쪽을 고른다. */
-const 날번호 = (ymd) => {
+const dayNumber = (ymd) => {
     const [y, m, d] = ymd.split('-').map(Number);
     return Math.round(Date.UTC(y, (m || 1) - 1, d || 1) / 86_400_000);
 };
 /** 항목을 가리키는 열쇠 — 자료의 id(없으면 name). 자료가 늘거나 차례가 바뀌어도 그 항목의 반쪽이 안 바뀌게 */
-const 항목열쇠 = (it, i) => {
+const itemKey = (it, i) => {
     const o = (it ?? {});
     return String(o.id ?? o.name ?? i);
 };
@@ -47,23 +47,23 @@ const 항목열쇠 = (it, i) => {
  * 정하고, 날 번호의 홀짝에 맞는 반쪽에서만 뽑는다** — 이웃한 두 날은 늘 다른 반쪽이라 겹치지 않고, 어제 보기는 어제 계산과 같다.
  * 두 반쪽이 모두 필요한 개수 이상일 때만(후보가 충분할 때) 이렇게 하고, 모자라면 전처럼 전체에서 뽑는다(빈 세트로 두지 않는다).
  */
-function 유형세트(pool, n, userId, ymd, type) {
+function typeSet(pool, n, userId, ymd, type) {
     if (!pool.length || n <= 0)
         return [];
     const rng = mulberry32(hashSeed(`${userId}|${ymd}|${type}`));
-    const 쪽 = 날번호(ymd) & 1;
-    const 이쪽 = pool.filter((it, i) => ((hashSeed(`${userId}|${type}|${항목열쇠(it, i)}`) >>> 7) & 1) === 쪽);
-    const 충분 = 이쪽.length >= n && pool.length - 이쪽.length >= n;
-    return sampleArray((충분 ? 이쪽 : pool), n, rng);
+    const side = dayNumber(ymd) & 1;
+    const thisSide = pool.filter((it, i) => ((hashSeed(`${userId}|${type}|${itemKey(it, i)}`) >>> 7) & 1) === side);
+    const enough = thisSide.length >= n && pool.length - thisSide.length >= n;
+    return sampleArray((enough ? thisSide : pool), n, rng);
 }
 // (user, 날짜)로 결정적 추출 → 기기/세션 무관 동일 선택. 유형마다 시드가 따로다(위 유형세트).
 function createSelection(counts, userId, ymd) {
-    const 개수 = (k) => Math.max(0, counts[k] || 0);
+    const countOf = (k) => Math.max(0, counts[k] || 0);
     return {
-        LISTEN_IN_NOISE: 유형세트(NOISE_DATAS, 개수('LISTEN_IN_NOISE'), userId, ymd, 'LISTEN_IN_NOISE'),
-        SHORT_STORY: 유형세트(SHORT_STORIES, 개수('SHORT_STORY'), userId, ymd, 'SHORT_STORY'),
-        LONG_STORY: 유형세트(LONG_STORIES, 개수('LONG_STORY'), userId, ymd, 'LONG_STORY'),
-        ORDERING_SENTENCE: 유형세트(ORDER_SETS, 개수('ORDERING_SENTENCE'), userId, ymd, 'ORDERING_SENTENCE'),
+        LISTEN_IN_NOISE: typeSet(NOISE_DATAS, countOf('LISTEN_IN_NOISE'), userId, ymd, 'LISTEN_IN_NOISE'),
+        SHORT_STORY: typeSet(SHORT_STORIES, countOf('SHORT_STORY'), userId, ymd, 'SHORT_STORY'),
+        LONG_STORY: typeSet(LONG_STORIES, countOf('LONG_STORY'), userId, ymd, 'LONG_STORY'),
+        ORDERING_SENTENCE: typeSet(ORDER_SETS, countOf('ORDERING_SENTENCE'), userId, ymd, 'ORDERING_SENTENCE'),
     };
 }
 export function hasItems(s) {

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

@@ -18,7 +18,7 @@
 const KST = 'Asia/Seoul';
 /* 시간대 없는 벽시계 시각 — 'YYYY-MM-DDTHH:mm[:ss[.fff…]]' 또는 가운데가 빈칸('YYYY-MM-DD HH:mm:ss', Postgres timestamp 꼴).
    뒤돌아보기 없이(iOS 15 Safari) 끝까지 맞춘다 — 뒤에 Z·±hh:mm 이 붙으면 걸리지 않는다. */
-const 벽시계시각 = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2})(?::(\d{2})(?:\.(\d+))?)?$/;
+const WALL_CLOCK = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2})(?::(\d{2})(?:\.(\d+))?)?$/;
 /**
  * 날짜·시각 값을 순간(Date)으로 읽는 **이 파일의 공용 파서.** 못 읽는 값(빈 값·깨진 글자)이면 null.
  *
@@ -28,13 +28,13 @@ const 벽시계시각 = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2})(?::(\d{2})(?:\.(\
  * 날짜만 있는 'YYYY-MM-DD' 는 지금 규칙(UTC 자정 = KST 같은 날 9시)을 그대로 따른다.
  * Date·숫자·오프셋 있는 글자는 그대로.
  */
-function 순간으로(when) {
+function toInstant(when) {
     let d;
     if (when instanceof Date)
         d = when;
     else if (typeof when === 'string') {
         const s = when.trim();
-        const m = 벽시계시각.exec(s);
+        const m = WALL_CLOCK.exec(s);
         /* 소수 초는 세 자리까지만 — 여섯 자리(Postgres)는 엔진마다 읽기가 갈린다 */
         d = new Date(m ? `${m[1]}T${m[2]}:${m[3] ?? '00'}${m[4] ? `.${m[4].slice(0, 3).padEnd(3, '0')}` : ''}+09:00` : s);
     }
@@ -44,16 +44,16 @@ function 순간으로(when) {
 }
 /* 못 읽는 값(빈 문자열·깨진 날짜)이면 null — 아래 형식 함수들이 화면에 "Invalid Date" 를 그대로 내던 것을 빈 글자로 막는다
    (같은 파일의 toKstYmd·formatYmd 는 이미 막고 있었다) */
-const 읽은날 = (iso) => 순간으로(iso);
+const parsed = (iso) => toInstant(iso);
 export function formatDateKo(iso) {
-    const d = 읽은날(iso);
+    const d = parsed(iso);
     if (!d)
         return '';
     return d.toLocaleDateString('ko-KR', { timeZone: KST, year: 'numeric', month: 'short', day: 'numeric' });
 }
 /** "2024년 1월 15일 오후 03:30" (long month + time) */
 export function formatDateLongKo(iso) {
-    const d = 읽은날(iso);
+    const d = parsed(iso);
     if (!d)
         return '';
     return d.toLocaleString('ko-KR', {
@@ -70,7 +70,7 @@ export function formatDateLongKo(iso) {
  */
 export function formatDateLocale(iso, lang) {
     const locale = lang.startsWith('ko') ? 'ko-KR' : 'en-US';
-    const d = 읽은날(iso);
+    const d = parsed(iso);
     if (!d)
         return '';
     return d.toLocaleDateString(locale, { timeZone: KST, year: 'numeric', month: 'short', day: 'numeric' });
@@ -78,7 +78,7 @@ export function formatDateLocale(iso, lang) {
 /** formatDateLongKo의 로케일 인식 버전 — en: "January 15, 2024, 03:30 PM" */
 export function formatDateLongLocale(iso, lang) {
     const locale = lang.startsWith('ko') ? 'ko-KR' : 'en-US';
-    const d = 읽은날(iso);
+    const d = parsed(iso);
     if (!d)
         return '';
     return d.toLocaleString(locale, {
@@ -89,7 +89,7 @@ export function formatDateLongLocale(iso, lang) {
 }
 /** "2024. 01. 15. 오후 03:30" (2-digit month + time) */
 export function formatDatetimeKo(iso) {
-    const d = 읽은날(iso);
+    const d = parsed(iso);
     if (!d)
         return '';
     return d.toLocaleString('ko-KR', {
@@ -110,7 +110,7 @@ export function formatDatetimeKo(iso) {
 export function toKstHm(when) {
     if (when === null || when === undefined || when === '')
         return '';
-    const d = 순간으로(when);
+    const d = toInstant(when);
     if (!d)
         return '';
     return new Intl.DateTimeFormat('en-GB', {
@@ -177,7 +177,7 @@ export function parseLocalYmd(ymd) {
 export function toKstYmd(when) {
     if (when === null || when === undefined || when === '')
         return '';
-    const d = 순간으로(when);
+    const d = toInstant(when);
     if (!d)
         return '';
     return new Intl.DateTimeFormat('fr-CA', { timeZone: 'Asia/Seoul' }).format(d);
@@ -191,7 +191,7 @@ export function toKstYmd(when) {
 export function formatRelativeTime(input, t) {
     if (!input)
         return '';
-    const d = 순간으로(input);
+    const d = toInstant(input);
     if (!d)
         return '';
     const then = d.getTime();

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

@@ -8,7 +8,7 @@
  * **왜 한 번만인가** — 컴포넌트는 다시 그려진다. 그릴 때마다 찍으면 콘솔이
  * 넘쳐서 진짜 봐야 할 것이 묻힌다.
  */
-const 찍은것 = new Set();
+const printed = new Set();
 export const isDev = (() => {
     try {
         if (import.meta.env?.DEV)
@@ -29,12 +29,12 @@ export const isDev = (() => {
 })();
 /** `key` 하나당 한 번만 찍는다. 운영 빌드에서는 아무 일도 하지 않는다. */
 export function devWarnOnce(key, ...args) {
-    if (!isDev || 찍은것.has(key))
+    if (!isDev || printed.has(key))
         return;
-    찍은것.add(key);
+    printed.add(key);
     console.warn(...args);
 }
 /** 시험용 — 기록을 비운다. 운영 코드에서 부를 일은 없다. */
 export function __resetDevWarnOnce() {
-    찍은것.clear();
+    printed.clear();
 }

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

@@ -1,13 +1,43 @@
 /**
- * 기기 종류(보청기·인공와우·기타)에 붙는 배지 색.
+ * 기기 종류(보청기·인공와우·기타) — **이름과 색을 한 자리에서 정한다.**
  *
- * 표(DeviceSideTable)와 '사용중인 기기' 패널(PanelRowDevice)이 같은 값을 각자
- * 그리므로 **규칙을 한 곳에 둔다** — 두 곳에서 따로 정하면 같은 인공와우가 한쪽은
- * 파랑, 한쪽은 초록으로 떠서 다른 것인 줄 알게 된다.
+ * 표(`DeviceSideTable`)와 '사용중인 기기' 패널(`PanelRowDevice`)이 같은 값을 각자 그리므로
+ * 규칙을 한 곳에 둔다 — 두 곳에서 따로 정하면 같은 인공와우가 한쪽은 파랑, 한쪽은 초록으로
+ * 떠서 다른 것인 줄 알게 된다.
  *
- * 값은 저장된 그대로의 한국어다(managed_device.type). 목록에 없는 값·빈 값은
- * 'default'(무채색)로 떨어뜨린다 — 모르는 종류를 아는 색으로 칠하지 않는다.
+ * **색만 모여 있고 이름은 안 모여 있었다** — `deviceTypeKeys`·`deviceTypeLabel` 이 그 두
+ * 파일에 **주석까지 똑같이 두 벌** 있었다(2026-10-13 말귀가 짚었다). 색에 적어 둔 그 까닭이
+ * 이름에도 그대로 들어맞는 자리다. 모았다.
  *
- * @public
+ * ## 값은 **코드**다 — 옛 한글 값도 받는다
+ *
+ * 저장값(`managed_device.type`)이 `'보청기'` 에서 `'hearingAid'` 로 옮겨 가는 중이다
+ * (사장님 지시 "저장된 한글 값도 다 영어로"). 앱이 판을 돌리는 때와 이 판이 깔리는 때가
+ * 어긋나고, 옛 자료를 보는 다른 기관이 있을 수 있어 **둘 다 받는다**.
+ *
+ * 받지 않으면 **터지지 않고 조용히 틀린다** — 배지에 `hearingAid` 가 날것으로 뜨고
+ * (`defaultValue: device` 로 떨어진다), 색이 둘 다 무채색이 되어 종류를 색으로 가르던 것이
+ * 사라진다. 눈으로만 잡히는 꼴이다.
+ */
+export type DeviceKind = 'hearingAid' | 'cochlearImplant' | 'other';
+/**
+ * 저장값을 종류 코드로 — 모르는 값은 `null`.
+ *
+ * **모르는 것을 `'other'` 로 접지 않는다.** 기타는 "기타" 라고 고른 값이고, 모르는 값은
+ * 아직 뜻을 모르는 것이다. 둘을 섞으면 새 종류가 생긴 날 조용히 '기타' 로 보인다.
+ */
+export declare function deviceKindOf(device: string | null | undefined): DeviceKind | null;
+/**
+ * 배지 색. 목록에 없는 값·빈 값은 `'default'`(무채색)로 떨어뜨린다 —
+ * **모르는 종류를 아는 색으로 칠하지 않는다.**
  */
 export declare function deviceKindVariant(device: string | null | undefined): string;
+/**
+ * 배지에 적을 이름 — **지금 언어로**. 사전(`device.type.*`)이 쥔다.
+ *
+ * 모르는 값은 **저장된 그대로** 보인다. 숨기지 않는다 — 화면에 날것이 보이면 자료에 무엇이
+ * 들어 있는지 알 수 있고, 빈칸이면 아무것도 알 수 없다.
+ */
+export declare function deviceKindLabel(device: string | null | undefined, t: (k: string, o: {
+    defaultValue: string;
+}) => string): string;

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

@@ -1,19 +1,62 @@
 /**
- * 기기 종류(보청기·인공와우·기타)에 붙는 배지 색.
+ * 기기 종류(보청기·인공와우·기타) — **이름과 색을 한 자리에서 정한다.**
  *
- * 표(DeviceSideTable)와 '사용중인 기기' 패널(PanelRowDevice)이 같은 값을 각자
- * 그리므로 **규칙을 한 곳에 둔다** — 두 곳에서 따로 정하면 같은 인공와우가 한쪽은
- * 파랑, 한쪽은 초록으로 떠서 다른 것인 줄 알게 된다.
+ * 표(`DeviceSideTable`)와 '사용중인 기기' 패널(`PanelRowDevice`)이 같은 값을 각자 그리므로
+ * 규칙을 한 곳에 둔다 — 두 곳에서 따로 정하면 같은 인공와우가 한쪽은 파랑, 한쪽은 초록으로
+ * 떠서 다른 것인 줄 알게 된다.
  *
- * 값은 저장된 그대로의 한국어다(managed_device.type). 목록에 없는 값·빈 값은
- * 'default'(무채색)로 떨어뜨린다 — 모르는 종류를 아는 색으로 칠하지 않는다.
+ * **색만 모여 있고 이름은 안 모여 있었다** — `deviceTypeKeys`·`deviceTypeLabel` 이 그 두
+ * 파일에 **주석까지 똑같이 두 벌** 있었다(2026-10-13 말귀가 짚었다). 색에 적어 둔 그 까닭이
+ * 이름에도 그대로 들어맞는 자리다. 모았다.
  *
- * @public
+ * ## 값은 **코드**다 — 옛 한글 값도 받는다
+ *
+ * 저장값(`managed_device.type`)이 `'보청기'` 에서 `'hearingAid'` 로 옮겨 가는 중이다
+ * (사장님 지시 "저장된 한글 값도 다 영어로"). 앱이 판을 돌리는 때와 이 판이 깔리는 때가
+ * 어긋나고, 옛 자료를 보는 다른 기관이 있을 수 있어 **둘 다 받는다**.
+ *
+ * 받지 않으면 **터지지 않고 조용히 틀린다** — 배지에 `hearingAid` 가 날것으로 뜨고
+ * (`defaultValue: device` 로 떨어진다), 색이 둘 다 무채색이 되어 종류를 색으로 가르던 것이
+ * 사라진다. 눈으로만 잡히는 꼴이다.
+ */
+/** 저장값 → 코드. 옛 한글 값도 받는다(위 머리말) */
+const TO_KIND = {
+    hearingAid: 'hearingAid', cochlearImplant: 'cochlearImplant', other: 'other',
+    // 열쇠가 **저장된 값**이라 따옴표를 쥐어 둔다 — 이름이 아니다(이름은 영어로 쓴다)
+    '보청기': 'hearingAid', '인공와우': 'cochlearImplant', '기타': 'other',
+};
+/**
+ * 저장값을 종류 코드로 — 모르는 값은 `null`.
+ *
+ * **모르는 것을 `'other'` 로 접지 않는다.** 기타는 "기타" 라고 고른 값이고, 모르는 값은
+ * 아직 뜻을 모르는 것이다. 둘을 섞으면 새 종류가 생긴 날 조용히 '기타' 로 보인다.
+ */
+export function deviceKindOf(device) {
+    /* `device && …` 를 `?? null` 로 받으면 **빈 글자가 새어 나간다** — `'' && x` 는 `''` 이고
+       `?? ` 는 `null`·`undefined` 만 받으므로 `deviceKindOf('')` 가 `''` 를 돌려줬다(tsc 가 잡았다).
+       빈 값은 "종류가 없다" 이지 "빈 이름의 종류" 가 아니다. */
+    if (!device)
+        return null;
+    return TO_KIND[device] ?? null;
+}
+/**
+ * 배지 색. 목록에 없는 값·빈 값은 `'default'`(무채색)로 떨어뜨린다 —
+ * **모르는 종류를 아는 색으로 칠하지 않는다.**
  */
 export function deviceKindVariant(device) {
-    switch (device) {
-        case '보청기': return 'main';
-        case '인공와우': return 'sub';
+    switch (deviceKindOf(device)) {
+        case 'hearingAid': return 'main';
+        case 'cochlearImplant': return 'sub';
         default: return 'default';
     }
 }
+/**
+ * 배지에 적을 이름 — **지금 언어로**. 사전(`device.type.*`)이 쥔다.
+ *
+ * 모르는 값은 **저장된 그대로** 보인다. 숨기지 않는다 — 화면에 날것이 보이면 자료에 무엇이
+ * 들어 있는지 알 수 있고, 빈칸이면 아무것도 알 수 없다.
+ */
+export function deviceKindLabel(device, t) {
+    const kind = deviceKindOf(device);
+    return kind ? t(`device.type.${kind}`, { defaultValue: device ?? '' }) : (device ?? '');
+}

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

@@ -6,10 +6,10 @@ import i18n from 'i18next';
  * 여기서 `../i18n` 을 가져오면 utils 묶음이 사전 JSON 과 init 부작용을 끌어안으므로 기본
  * 인스턴스를 직접 본다. 초기화 전의 `i18n.t` 는 undefined 를 돌려준다.
  */
-const 알수없는오류 = () => {
-    const 기본 = '알 수 없는 오류';
-    const s = typeof i18n?.t === 'function' ? i18n.t('common.unknownError', { defaultValue: 기본 }) : undefined;
-    return typeof s === 'string' && s ? s : 기본;
+const unknownError = () => {
+    const fallback = '알 수 없는 오류';
+    const s = typeof i18n?.t === 'function' ? i18n.t('common.unknownError', { defaultValue: fallback }) : undefined;
+    return typeof s === 'string' && s ? s : fallback;
 };
 /**
  * 잡은 값에서 **사람이 읽을 수 있는 원인**을 꺼낸다.
@@ -33,7 +33,7 @@ const 알수없는오류 = () => {
 export function getErrorMessage(e, fallback) {
     // 기본 문구는 부를 때마다 지금 언어로 만든다(모듈 로드 때 한 번 정하면 언어 전환을 못 따른다)
     if (fallback === undefined)
-        fallback = 알수없는오류();
+        fallback = unknownError();
     if (e instanceof Error)
         return e.message || fallback;
     if (typeof e === 'string')
@@ -58,7 +58,7 @@ export function getErrorMessage(e, fallback) {
 export const NETWORK_ERROR_MESSAGE = '네트워크 연결이 불안정합니다. 연결 상태를 확인한 뒤 다시 시도해 주세요.';
 /* 화면에 내는 것은 지금 언어로(`common.networkError`, 사전에 없으면 위 한국어) — 상수만 돌려줘 영어 화면 토스트도 한국어였다.
    상수는 옛 소비자가 견주는 값이라 그대로 둔다. */
-const 네트워크오류 = () => {
+const networkError = () => {
     const s = typeof i18n?.t === 'function' ? i18n.t('common.networkError', { defaultValue: NETWORK_ERROR_MESSAGE }) : undefined;
     return typeof s === 'string' && s ? s : NETWORK_ERROR_MESSAGE;
 };
@@ -82,5 +82,5 @@ export function isNetworkErrorMessage(msg) {
  * @public
  */
 export function toUserErrorMessage(msg) {
-    return isNetworkErrorMessage(msg) ? 네트워크오류() : msg;
+    return isNetworkErrorMessage(msg) ? networkError() : msg;
 }