@ihabdevteam/core 0.321.0 → 0.323.0

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

@@ -119,22 +119,22 @@ export function buildPositionSection(t, opts) {
  * 저장할 때는 `toWordAttributeFilterCodes` 로 코드 모양을 함께 담는다.
  */
 export function toggleAttributeFilter(prev, value, sectionLabel) {
-    const 섹션 = wordAttributeSectionOf(sectionLabel);
-    const 값코드 = 섹션 && value !== FILTER_ALL_VALUE ? wordAttributeValueCodeOf(섹션, value) : null;
-    if (섹션 && (value === FILTER_ALL_VALUE || 값코드)) {
-        const 남김 = {};
-        const 같은섹션 = {};
+    const section = wordAttributeSectionOf(sectionLabel);
+    const valueCode = section && value !== FILTER_ALL_VALUE ? wordAttributeValueCodeOf(section, value) : null;
+    if (section && (value === FILTER_ALL_VALUE || valueCode)) {
+        const kept = {};
+        const sameSection = {};
         for (const [k, v] of Object.entries(prev))
-            (wordAttributeSectionOf(k) === 섹션 ? 같은섹션 : 남김)[k] = v;
+            (wordAttributeSectionOf(k) === section ? sameSection : kept)[k] = v;
         if (value === FILTER_ALL_VALUE)
-            return 남김;
-        const 지금 = toWordAttributeFilterCodes(같은섹션)[섹션] ?? [];
-        const 다음 = 지금.includes(값코드) ? 지금.filter(c => c !== 값코드) : [...지금, 값코드];
-        if (다음.length === 0)
-            return 남김;
-        const 라벨 = wordAttributeFilterFromCodes({ [섹션]: 다음 }, wordAttributeLabelLanguageOf(sectionLabel));
-        const 값들 = Object.values(라벨)[0] ?? [];
-        return { ...남김, [sectionLabel]: 값들 };
+            return kept;
+        const current = toWordAttributeFilterCodes(sameSection)[section] ?? [];
+        const nextCodes = current.includes(valueCode) ? current.filter(c => c !== valueCode) : [...current, valueCode];
+        if (nextCodes.length === 0)
+            return kept;
+        const labels = wordAttributeFilterFromCodes({ [section]: nextCodes }, wordAttributeLabelLanguageOf(sectionLabel));
+        const values = Object.values(labels)[0] ?? [];
+        return { ...kept, [sectionLabel]: values };
     }
     if (value === FILTER_ALL_VALUE) {
         const { [sectionLabel]: _omit, ...rest } = prev;

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

@@ -28,8 +28,8 @@ const memCache = new Map();
 const noMeaning = new Set();
 /* 빈 응답(한 줄도 못 받음)으로 '뜻 없음' 이 된 열쇠와 그 때 — 조회 함수는 실패도 빈 배열로 돌려주므로 영영 굳히지 않고, 사용자 추가
    낱말처럼 정말 뜻이 없는 쪽을 오갈 때마다 다시 묻지도 않게 **잠시만**(1분) 묻지 않는다. */
-const 빈응답때 = new Map();
-const 빈응답유예ms = 60_000;
+const emptyAt = new Map();
+const EMPTY_GRACE_MS = 60_000;
 export function useWordMeanings(rows, fetchMeanings) {
     /* 캐시는 모듈 스코프 Map 이라 갱신이 렌더에 자동 반영되지 않는다 — 조회가 끝나면 이 값을
        올려 아래 스냅샷을 다시 계산시킨다(캐시 히트만으로 리렌더가 연쇄되지 않도록 분리). */
@@ -39,8 +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 지금 = Date.now();
-        const missing = wanted.filter(k => !memCache.has(k) && !noMeaning.has(k) && !(지금 - (빈응답때.get(k) ?? -Infinity) < 빈응답유예ms));
+        const now = Date.now();
+        const missing = wanted.filter(k => !memCache.has(k) && !noMeaning.has(k) && !(now - (emptyAt.get(k) ?? -Infinity) < EMPTY_GRACE_MS));
         if (missing.length === 0)
             return; // 전부 캐시에 있음 — 네트워크·상태 갱신 불필요
         let cancelled = false;
@@ -62,7 +62,7 @@ export function useWordMeanings(rows, fetchMeanings) {
             else {
                 const t = Date.now();
                 for (const k of missing)
-                    빈응답때.set(k, t);
+                    emptyAt.set(k, t);
             }
             if (cancelled || got.length === 0)
                 return;

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

@@ -56,9 +56,11 @@ export interface WordTrainingFilterCaps {
  * 등급 고르개의 설명 줄들 — 지금 언어로. 사전에 배열이 없으면 한국어 원문.
  *
  * **공개 API 가 아니다**(대응표에 `internal`) — 코어 안에서만 쓰고, 내보내는 것은 못이 읽기 때문이다.
+ * 그래도 **이름은 영어다** — `internal` 이라도 배포 `d.ts` 에는 그대로 나가 소비자 편집기에 보인다
+ * (사용자 지시 2026-10-13. 소비자 사용처 0 이라 옛 이름을 남기지 않았다 — 말귀의 같은 이름 함수는 제 지역 것이다).
  * 앱은 제 열쇠(`wordSearch.filter.gradeInfo`)와 제 받는 함수를 따로 갖는다.
  */
-export declare function 등급설명(t: TFunction): string[];
+export declare function gradeDescriptions(t: TFunction): string[];
 export declare function useWordTrainingFilter(groupKey: string, caps: WordTrainingFilterCaps, opts?: {
     resetOnMount?: boolean;
     resetKey?: string;

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

@@ -8,7 +8,7 @@ import { useWordAttributeFilterKeys, buildGradeSection, buildPartOfSpeechSection
 import { matchesFilters } from '../utils/phonemePairSearch';
 import { wordAttributeValueCodeOf, wordAttributeValueLabelOf, isGradeCode } from '../utils/wordAttributeFilterCodes';
 /** 저장된 등급을 되읽을 때 코드 아닌 것은 버린다 — 0.320.0 작업본이 잠깐 `['']` 를 저장했다 */
-const 등급코드만 = (v) => (Array.isArray(v) ? v.filter(isGradeCode) : []);
+const gradeCodesOnly = (v) => (Array.isArray(v) ? v.filter(isGradeCode) : []);
 import { hasSel } from '../utils/wordContrast';
 import { phoneticLabel } from '../utils/phonemeGroups';
 /* 글자↔발음 변환과 음절 상수는 wordTrainingFilterModel.ts 로 옮겼다(React 없는 순수 계층).
@@ -78,7 +78,7 @@ function readComposition(saved) {
  * @public
  */
 /** 사전이 배열을 안 주면 한국어 원문으로 물러선다 — 빈 줄을 띄우지 않는다((205)) */
-const 등급설명기본 = [
+const GRADE_DESCRIPTIONS_KO = [
     '1등급 : 학령전기에 습득하여 평생에 걸쳐 일상 언어생활을 하는 데 사용되는 어휘',
     '2등급 : 초등학교 1-2학년 난이도 어휘',
     '3등급 : 초등학교 3-4학년 난이도 어휘',
@@ -89,11 +89,13 @@ const 등급설명기본 = [
  * 등급 고르개의 설명 줄들 — 지금 언어로. 사전에 배열이 없으면 한국어 원문.
  *
  * **공개 API 가 아니다**(대응표에 `internal`) — 코어 안에서만 쓰고, 내보내는 것은 못이 읽기 때문이다.
+ * 그래도 **이름은 영어다** — `internal` 이라도 배포 `d.ts` 에는 그대로 나가 소비자 편집기에 보인다
+ * (사용자 지시 2026-10-13. 소비자 사용처 0 이라 옛 이름을 남기지 않았다 — 말귀의 같은 이름 함수는 제 지역 것이다).
  * 앱은 제 열쇠(`wordSearch.filter.gradeInfo`)와 제 받는 함수를 따로 갖는다.
  */
-export function 등급설명(t) {
-    const v = t('wordPairs.filter.difficultyInfo', { returnObjects: true, defaultValue: 등급설명기본 });
-    return Array.isArray(v) && v.length > 0 && v.every(x => typeof x === 'string') ? v : 등급설명기본;
+export function gradeDescriptions(t) {
+    const v = t('wordPairs.filter.difficultyInfo', { returnObjects: true, defaultValue: GRADE_DESCRIPTIONS_KO });
+    return Array.isArray(v) && v.length > 0 && v.every(x => typeof x === 'string') ? v : GRADE_DESCRIPTIONS_KO;
 }
 export function useWordTrainingFilter(groupKey, caps, opts) {
     const { t, i18n } = useTranslation();
@@ -143,12 +145,12 @@ export function useWordTrainingFilter(groupKey, caps, opts) {
     // 음소 구조 같은 단어만(초성 ㅇ 유무·받침 유무 대립 제외) — 기본 true (reset 시 OFF)
     const [sameStructureOnly, setSameStructureOnly] = useState(opts?.resetOnMount ? false : (saved?.sameStructureOnly ?? true));
     // 난이도 등급('1'~'4') 필터 — 배열(다중 선택), 빈 배열은 전체(무제약)
-    const [gradeFilter, setGradeFilter] = useState(등급코드만(saved?.gradeFilter));
+    const [gradeFilter, setGradeFilter] = useState(gradeCodesOnly(saved?.gradeFilter));
     // 품사/어종 필터 — 단어표·대립쌍표와 동일 라벨 배열(다중 선택). caps로 노출 여부 결정(기본 미노출).
-    const 라벨언어들 = Array.from(new Set([i18n.language, 'ko', 'en'].filter(Boolean)));
+    const labelLanguages = Array.from(new Set([i18n.language, 'ko', 'en'].filter(Boolean)));
     const labelOf = (lng, key) => i18n.getFixedT(lng)(key);
-    const posCodesOf = (v) => toAttrCodes(v, POS_CODES, c => `wordSearch.filter.pos.${c}`, labelOf, 라벨언어들);
-    const typeCodesOf = (v) => toAttrCodes(v, TYPE_CODES, c => `wordSearch.filter.type.${c}`, labelOf, 라벨언어들);
+    const posCodesOf = (v) => toAttrCodes(v, POS_CODES, c => `wordSearch.filter.pos.${c}`, labelOf, labelLanguages);
+    const typeCodesOf = (v) => toAttrCodes(v, TYPE_CODES, c => `wordSearch.filter.type.${c}`, labelOf, labelLanguages);
     const [posCodes, setPosCodes] = useState(() => posCodesOf(saved?.posFilter));
     const [typeCodes, setTypeCodes] = useState(() => typeCodesOf(saved?.wordTypeFilter));
     // 훈련 타입(resetKey) 변경 시 필터를 그 타입 기본값으로 초기화 — 이전 타입의 고정값(음절수/받침/한음절 시드)이
@@ -211,7 +213,7 @@ export function useWordTrainingFilter(groupKey, caps, opts) {
             setSameStructureOnly(s?.sameStructureOnly ?? true);
             // 마운트 때와 같은 규칙 — 여기서만 'direct' 를 'char' 로 떨구고 있었다
             setPhonemeView(readPhonemeView(s));
-            setGradeFilter(등급코드만(s?.gradeFilter));
+            setGradeFilter(gradeCodesOnly(s?.gradeFilter));
             setPosCodes(posCodesOf(s?.posFilter));
             setTypeCodes(typeCodesOf(s?.wordTypeFilter));
         }
@@ -450,7 +452,7 @@ export function useWordTrainingFilter(groupKey, caps, opts) {
                    사전이 배열을 안 주면(옛 사전을 덮어쓴 소비자 등) **한국어 원문으로 물러선다** — 빈 줄을
                    띄우지 않는다. 재 보고 적는다: `returnObjects` 는 배열을 그대로 주고 `defaultValue` 도
                    배열로 물러선다(i18next 26.4.1). */
-                labelInfo: infoAction(등급설명(t)),
+                labelInfo: infoAction(gradeDescriptions(t)),
             }),
             label: LABELS.gradeLabel,
         });
@@ -619,7 +621,7 @@ export function useWordTrainingFilter(groupKey, caps, opts) {
         setExcludeNoImage(s.excludeNoImage);
         setSameStructureOnly(s.sameStructureOnly ?? true);
         setPhonemeView(s.phonemeView);
-        setGradeFilter(등급코드만(s.gradeFilter));
+        setGradeFilter(gradeCodesOnly(s.gradeFilter));
         if (Array.isArray(s.posFilter))
             setPosCodes(posCodesOf(s.posFilter));
         if (Array.isArray(s.wordTypeFilter))

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

@@ -114,6 +114,7 @@
             "Fri",
             "Sat"
         ],
+        "weekLabel": "Week {{ord}}",
         "yearMonth": "{{month}}/{{year}}",
         "prevMonth": "Previous month",
         "addOnDate": "Add a visit on {{date}}",
@@ -128,7 +129,16 @@
         "periodSelect": "Period unit",
         "visitCount_one": "{{count}} visit",
         "visitCount_other": "{{count}} visits",
-        "statusCount": "{{count}} {{label}}"
+        "statusCount": "{{count}} {{label}}",
+        "weekOrdinal": [
+            "1",
+            "2",
+            "3",
+            "4",
+            "5",
+            "6",
+            "7"
+        ]
     },
     "passCard": {
         "planSuffix": "Plan",
@@ -1059,7 +1069,8 @@
         "removeDevice": "Remove",
         "type": {
             "hearingAid": "Hearing Aid",
-            "cochlearImplant": "Cochlear Implant"
+            "cochlearImplant": "Cochlear Implant",
+            "other": "Other"
         }
     },
     "manager": {

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

@@ -110,6 +110,16 @@
             "금",
             "토"
         ],
+        "weekOrdinal": [
+            "첫째",
+            "둘째",
+            "셋째",
+            "넷째",
+            "다섯째",
+            "여섯째",
+            "일곱째"
+        ],
+        "weekLabel": "{{ord}}주",
         "yearMonth": "{{year}}년 {{month}}월",
         "prevMonth": "이전 달",
         "addOnDate": "{{date}}에 방문 등록",
@@ -1048,7 +1058,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.d.ts

@@ -1,5 +1,5 @@
 export declare const isDev: boolean;
-/** `키` 하나당 한 번만 찍는다. 운영 빌드에서는 아무 일도 하지 않는다. */
-export declare function devWarnOnce(키: string, ...말: unknown[]): void;
+/** `key` 하나당 한 번만 찍는다. 운영 빌드에서는 아무 일도 하지 않는다. */
+export declare function devWarnOnce(key: string, ...args: unknown[]): void;
 /** 시험용 — 기록을 비운다. 운영 코드에서 부를 일은 없다. */
 export declare function __resetDevWarnOnce(): void;

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)
@@ -27,14 +27,14 @@ export const isDev = (() => {
         return false;
     }
 })();
-/** `키` 하나당 한 번만 찍는다. 운영 빌드에서는 아무 일도 하지 않는다. */
-export function devWarnOnce(키, ...말) {
-    if (!isDev || 찍은것.has(키))
+/** `key` 하나당 한 번만 찍는다. 운영 빌드에서는 아무 일도 하지 않는다. */
+export function devWarnOnce(key, ...args) {
+    if (!isDev || printed.has(key))
         return;
-    찍은것.add(키);
-    console.warn(...말);
+    printed.add(key);
+    console.warn(...args);
 }
 /** 시험용 — 기록을 비운다. 운영 코드에서 부를 일은 없다. */
 export function __resetDevWarnOnce() {
-    찍은것.clear();
+    printed.clear();
 }