@ihabdevteam/core 0.344.0 → 0.346.0

package/dist/ihabdevteam-core.d.ts

@@ -1754,7 +1754,7 @@ export declare function copyText(text: string): Promise<boolean>;
  *
  * 값은 손으로 적고 `test/coreVersion.test.ts` 가 package.json 과 어긋나면 운다.
  */
-export declare const CORE_VERSION = "0.344.0";
+export declare const CORE_VERSION = "0.346.0";
 
 /** @public */
 declare const coreDefault: Record<string, unknown>;
@@ -2693,10 +2693,6 @@ declare interface FooterProps {
  */
 export declare function formatCount(n: number | null | undefined): string;
 
-/**
- * 날짜 포맷 유틸 — 산재한 Date 파싱 로직을 공유.
- * 각 화면의 표시 형식 차이는 옵션으로 흡수.
- */
 export declare function formatDateKo(iso: string): string;
 
 /**
@@ -8955,23 +8951,6 @@ export declare interface TrainingItem {
     [k: string]: unknown;
 }
 
-/**
- * 훈련 한 판의 **문항 하나하나**를 기록할 수 있는 모양으로 추린다.
- *
- * 08-26 회의에서 치료사가 "음소별 오류를 보고 싶다"고 했다. 그러려면 어느 낱말을
- * 틀렸는지가 남아야 하는데, 지금은 안 남는다 — `customer_training_result` 의
- * `item_id`·`item_title` 이 전부 null 이다.
- *
- * 정보가 없어서가 아니다. 훈련이 끝나는 순간 화면은 문항마다
- * `{ question, choices, selected, selectedText, correct, answer }` 를 들고 있다
- * (trainingPopupUtils 의 build*Results). 그걸 `correct/total` 두 숫자로 접어서 버리고
- * 있었다. 접기 전에 한 번 추려 둔다.
- *
- * **음소를 여기서 뽑지 않는다.** 낱말을 남기는 것과 그 낱말에서 음소를 세는 것은 다른
- * 일이고, 뒤엣것은 아직 규칙이 정해지지 않았다(어두/어중/어말 위치 모델도 바뀌는 중이다).
- * 지금 섣불리 음소를 박아 두면, 규칙이 바뀔 때 이미 쌓인 기록이 옛 규칙으로 남는다.
- * 낱말은 사실이고 음소는 해석이다 — 사실만 남긴다.
- */
 /** @public 훈련 한 문항의 결과 — 서버에 남길 만큼만 추린 것 */
 export declare interface TrainingItemResult {
     /** 몇 번째 문항인가(0부터) — 같은 낱말이 두 번 나와도 구별된다 */
@@ -11147,14 +11126,6 @@ export declare interface WordSearchResultGroup {
 export declare interface WordSearchResultItem {
     id: string;
     words: WordSearchResultWord[];
-    /**
-     * 갈린 자리 — **옛 한글 이름**(`'초성'`·`'모음'`·`'종성'`·`'활음'`)이다.
-     *
-     * @deprecated `diffSectionCode` 를 쓴다 — 같은 자리를 코드로 가리킨다. 2026-10-13 안쪽을
-     * 코드로 옮겼지만 **소비자가 이 값으로 묶음을 가른다**(말귀 `WordPairsPage` 의 `GROUP_ORDER`).
-     * 혼자 바꾸면 그쪽 묶음이 조용히 빈다. 소비자가 옮긴 뒤 걷는다.
-     */
-    diffSection?: string;
     /** 갈린 자리 — 코드(`'onset'`·`'vowel'`·`'coda'`·`'glide'`). 이쪽이 정본이다. */
     diffSectionCode?: PhonemeSectionCode;
     diffHasEmpty?: boolean;

package/dist/packages/core/src/components/Training/TrainingStepAudioPlayer.css

@@ -248,11 +248,22 @@
   box-shadow: 0 0 6px rgba(0,0,0,0.4);
 }
 
-/* Show spinner only during loading — hide the textual label.
-   !important 불필요 — .audio-player__loading-text의 display를 지정하는 규칙이 이것뿐이라 경합 대상이 없음. */
+/* **눈에서 감추되 낭독기에는 남긴다**(사장님 결정 (다), 2026-10-19 — (305)).
+   전에는 `display: none` 이었다. 글자는 안 보였지만 **접근성 나무에서도 빠져** 기다리는
+   동안 아무 말도 안 읽혔다 — 위의 `role="status"`·`aria-live` 가 헛돌았다.
+   저장소 처음부터 그랬다(`speechear 복사본`).
+
+   이 저장소가 쓰는 감추는 규약(`Table.css`·`Board.css`·`WordTable.css` 의 `clip-path: inset(50%)`)
+   을 그대로 쓴다 — 자리를 안 차지하고 보이지 않지만 **읽힌다.**
+   `display: none` 이나 `visibility: hidden` 으로 바꾸면 읽히는 것이 다시 사라진다. */
 .audio-player__loading .audio-player__loading-text,
 .audio-player__panel.is-loading .audio-player__loading-text {
-    display: none;
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
 }
 
 .audio-player__loading-spinner {

package/dist/packages/core/src/components/Training/TrainingStepAudioPlayer.js

@@ -18,7 +18,9 @@ import Toast from '../Toast';
 import Button from '../Button';
 import Icon from '../Icon';
 import InfoTooltip from '../Tooltip/InfoTooltip';
-import { STATUS_MESSAGES, ANNOUNCED_STATUSES } from './trainingStepAudioPlayerTypes';
+/* `STATUS_MESSAGES` 를 더는 안 들여온다 — 걸음마다 다른 글을 화면에 쓰지 않기 때문이다
+   (사장님 결정 (다), 2026-10-19). 그 표는 **지우지 않았다**: 개발 판의 자취와 색이 쓴다. */
+import { ANNOUNCED_STATUSES } from './trainingStepAudioPlayerTypes';
 import { wasKeyboardPress } from '../../hooks/inputModality';
 import { measureAudioDuration, waitForCanPlay } from './audioWaits';
 import { useWaveReady } from './useWaveReady';
@@ -1418,10 +1420,20 @@ export default function TrainingStepAudioPlayer({ btnLabel, soundSrc, bucketPath
     const fillLeftPercent = Math.max(0, Math.min(100, (progress || 0) * 100));
     const fillClass = cx('audio-player__fill', fillVisibleFlag ? 'is-visible' : '', fillExpandedFlag ? 'is-expanded' : '', fillPausedFlag ? 'is-paused' : '', isFillOutAnimating ? 'is-out' : '');
     return (_jsxs("div", { className: `audio-player ${isDisabled ? 'is-disabled' : ''}${className ? ` ${className}` : ''}`, role: "group", "aria-label": typeof label === 'string' ? label : undefined, children: [_jsxs("div", { className: `audio-player__panel ${displayedPlaying ? "is-playing" : ""} ${isFetchingUrl ? "is-loading" : ""} ${stateLocal !== "default" ? "is-revealed" : ""}`, children: [isFetchingUrl ? (
-                    /* **알릴 값이 있을 때만 읽히게 한다**(사장님 결정 (나), 2026-10-05).
-                       `준비 완료` 는 일이 끝난 뒤의 알림이라, 소리 한 번에 말 한 마디가 거저 얹혔다.
-                       보이는 글은 그대로다 — 읽히는 것만 준다(`ANNOUNCED_STATUSES`). */
-                    _jsxs("div", { className: "audio-player__loading", role: ANNOUNCED_STATUSES[fetchDebugStatus] ? 'status' : undefined, "aria-live": ANNOUNCED_STATUSES[fetchDebugStatus] ? 'polite' : 'off', children: [_jsx("span", { className: "audio-player__loading-spinner", "aria-hidden": "true" }), _jsx("span", { className: "audio-player__loading-text", children: t(`training.audioStatus.${fetchDebugStatus}`, { defaultValue: STATUS_MESSAGES[fetchDebugStatus] }) })] })) : null, stateLocal === "active" ? (_jsx("button", { className: "audio-player__button", type: "button", 
+                    /* **기다리는 동안 글자를 안 띄운다**(사장님 결정 (다), 2026-10-19 — (305)).
+                       전에는 걸음마다 글이 바뀌었다: `소리를 만들고 있습니다…` 가 **2ms 뒤에**
+                       `리소스 매핑 중…` 으로 덮이고 `서명 URL 조회…` · `다운로드 중…` 까지 늘어섰다
+                       (말귀 실측 2026-10-19: 캐시가 다 찬 가장 짧은 판에서도 94ms · 746ms).
+                       사장님 규칙은 **개발자의 말을 화면에 쓰지 않는다**다.
+          
+                       골라 둔 길 (가)(사람 말 한 마디로 묶기)가 아니라 **글을 아예 없애는** 쪽으로
+                       정하셨다 — 깜박이는 글은 한 마디로 묶어도 읽을 틈이 없다. 눈에는 동그라미만,
+                       **낭독기에는 한 마디**를 남긴다(그쪽은 깜박임이 없다).
+          
+                       `ANNOUNCED_STATUSES` 는 그대로 쓴다(사장님 결정 (나), 2026-10-05) — `준비 완료`
+                       처럼 일이 끝난 뒤의 알림은 읽히지 않는다. 걸음 이름과 그 글(`STATUS_MESSAGES`)은
+                       **지우지 않는다**: 개발 판의 자취와 색이 그것을 쓴다. */
+                    _jsxs("div", { className: "audio-player__loading", role: ANNOUNCED_STATUSES[fetchDebugStatus] ? 'status' : undefined, "aria-live": ANNOUNCED_STATUSES[fetchDebugStatus] ? 'polite' : 'off', children: [_jsx("span", { className: "audio-player__loading-spinner", "aria-hidden": "true" }), _jsx("span", { className: "audio-player__loading-text", children: t('training.audioStatus.preparing', { defaultValue: '소리를 준비하고 있습니다…' }) })] })) : null, stateLocal === "active" ? (_jsx("button", { className: "audio-player__button", type: "button", 
                         /* 막힌 단계(아직 차례가 아닌 듣기·합성 주소를 받는 중)는 CSS pointer-events 로만 막아, Tab 으로 와서 Enter 를
                            누르면 소리를 받으러 가거나 "가져오지 못했습니다" 를 띄웠다 — 마우스와 같게 키보드도 막는다 */
                         disabled: isDisabled, 

package/dist/packages/core/src/components/Word/WordSearchResultBlock.css

@@ -135,6 +135,14 @@
     gap: 10px;
 }
 
+/* 묶음 이름 머리(말귀 청 (308)) — 앱이 `초성 대비`·`모음 대비` 처럼 넘긴다.
+   **글자 크기는 여기서 안 정한다** — 이 저장소는 `styles.css` 의 공용 클래스(`caption-1b`)로
+   준다(`date-picker__dow caption-1` 따위가 그 꼴이다). 세우다 `--font-label-m` 이라는
+   **없는 토큰**을 적었는데, 없는 변수는 조용히 아무 꼴도 안 내서 깨진 줄 몰랐다. */
+.word-search-result-block__group-label {
+    color: var(--color-gray);
+}
+
 .word-search-result-block__group + .word-search-result-block__group {
     margin-top: var(--spacing-l);
     padding-top: var(--spacing-l);

package/dist/packages/core/src/components/Word/WordSearchResultBlock.js

@@ -3,7 +3,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { cx } from '../../utils/cx';
 import { compareKorean } from '../../utils/textSort';
 import { useEscToClose } from '../../hooks/useEscToClose';
-import { useState, useCallback, useMemo, useEffect } from 'react';
+import { useState, useCallback, useMemo, useEffect, useId } from 'react';
 import { useTranslation } from 'react-i18next';
 import './WordSearchResultBlock.css';
 import Button from '../Button';
@@ -126,6 +126,9 @@ export default function WordSearchResultBlock({ titleIcon, resultCount, resultUn
     const pageClamped = Math.min(page, totalPages);
     const pagedItems = useMemo(() => sortedItems.slice((pageClamped - 1) * pageSize, pageClamped * pageSize), [sortedItems, pageClamped, pageSize]);
     // 현재 페이지의 그룹 항목을 그룹 순서대로 재그룹핑한다(그룹 헤더 유지; 페이지 경계에서 한 그룹이 나뉠 수 있음).
+    /* 묶음 이름표의 id 뿌리 — 한 쪽에 이 묶음이 둘 이상 설 수 있어 `useId()` 로 가른다.
+       이름 자체를 꼬리로 붙인다(한 쪽 안에서 `Map` 열쇠라 겹치지 않는다). */
+    const groupLabelBaseId = useId();
     const pagedGroups = useMemo(() => {
         if (!groups)
             return null;
@@ -180,15 +183,24 @@ export default function WordSearchResultBlock({ titleIcon, resultCount, resultUn
        과 아주 같은 h4 로 맞췄는데, 그러니 결과 덩이의 머리가 그 위 판 제목들(`검색 옵션` ·
        `단어 검색 설정`)과 같은 급이 되어 **무엇이 무엇의 머리인지 안 보였다.** 거르개 판은
        결과를 고르는 도구고 이 덩이는 그 결과라, 나란한 것이 아니라 아래 딸린 것이다. */
-    _jsxs(Section, { type: sectionType, className: cx('word-search-result-block', className), children: [_jsxs("div", { className: "word-search-result-block__inner", children: [(titleLabel || toolbar || discNode) && (_jsxs("div", { className: "word-search-result-block__head", children: [_jsxs("div", { className: "word-search-result-block__head-main", children: [titleIcon && _jsx(Icon, { icon: titleIcon, className: "word-search-result-block__head-icon" }), titleLabel && _jsx("span", { className: "word-search-result-block__title h3", children: titleLabel })] }), toolbar && _jsx("div", { className: "word-search-result-block__head-actions", children: toolbar }), discNode && _jsx("div", { className: "word-search-result-block__head-disc body-3", children: discNode })] })), (groups ? groups.length === 0 : items.length === 0) && (_jsxs("div", { className: "word-search-result-block__empty-wrap", children: [_jsx("p", { className: "word-search-result-block__empty body-3", children: t('wordSearch.emptyResult', '검색 결과가 없습니다.') }), emptyHint && _jsx("p", { className: "word-search-result-block__empty-hint body-3", children: emptyHint })] })), groups ? ((pagedGroups ?? []).map((group) => (_jsx("div", { className: "word-search-result-block__group", children: _jsx("div", { className: "word-search-result-block__items", children: group.items.map((item) => {
-                                const isSelected = selected.includes(item.id);
-                                return (_jsx("div", { onMouseEnter: e => {
-                                        openHover(e.currentTarget);
-                                        setHoverWords(item.words ?? []);
-                                    }, onMouseLeave: handleHoverLeave, children: _jsx(Button, { htmlType: "button", size: "word", align: "grid", label: (item.words ?? []).map(w => w.label), subLabel: (item.words ?? []).some(w => w.subLabel)
-                                            ? (item.words ?? []).map(w => w.subLabel)
-                                            : undefined, selected: isSelected, onClick: () => handleClick(item.id), minWidth: 200 }) }, item.id));
-                            }) }) }, group.label)))) : (_jsx("div", { className: "word-search-result-block__items", children: pagedItems.map((item) => {
+    _jsxs(Section, { type: sectionType, className: cx('word-search-result-block', className), children: [_jsxs("div", { className: "word-search-result-block__inner", children: [(titleLabel || toolbar || discNode) && (_jsxs("div", { className: "word-search-result-block__head", children: [_jsxs("div", { className: "word-search-result-block__head-main", children: [titleIcon && _jsx(Icon, { icon: titleIcon, className: "word-search-result-block__head-icon" }), titleLabel && _jsx("span", { className: "word-search-result-block__title h3", children: titleLabel })] }), toolbar && _jsx("div", { className: "word-search-result-block__head-actions", children: toolbar }), discNode && _jsx("div", { className: "word-search-result-block__head-disc body-3", children: discNode })] })), (groups ? groups.length === 0 : items.length === 0) && (_jsxs("div", { className: "word-search-result-block__empty-wrap", children: [_jsx("p", { className: "word-search-result-block__empty body-3", children: t('wordSearch.emptyResult', '검색 결과가 없습니다.') }), emptyHint && _jsx("p", { className: "word-search-result-block__empty-hint body-3", children: emptyHint })] })), groups ? ((pagedGroups ?? []).map((group) => (
+                    /* **묶음 이름을 머리로 그린다**(말귀 청 (308), 2026-10-19).
+                       `pagedGroups` 가 `label` 을 들고 왔는데 **그리는 자리에서 안 썼다** — 받은 이름이
+                       `key` 로만 쓰이고 사라져, 보는 사람은 어느 자리가 갈린 쌍인지 모른 채 한 덩어리로
+                       봤다(말귀 실측: 묶음 네 개를 넘겼는데 `__group` 이 1 개, 이름 글자 0 건, 1,159쌍).
+                       `pagedGroups` 가 쪽마다 다시 묶으므로 **쪽 경계에서 나뉘면 나뉜 쪽에도 다시 선다.**
+        
+                       이름을 `aria-labelledby` 로 가리킨다 — `IconGridMenu` 가 쓰는 규약이다.
+                       `role="group"` 은 **이름이 없으면 낭독기가 묶음을 안 알린다**(`ColorPicker` 의 주석). */
+                    _jsxs("div", { className: "word-search-result-block__group", role: "group", "aria-labelledby": `${groupLabelBaseId}-${group.label}`, children: [_jsx("div", { className: "word-search-result-block__group-label caption-1b", id: `${groupLabelBaseId}-${group.label}`, children: group.label }), _jsx("div", { className: "word-search-result-block__items", children: group.items.map((item) => {
+                                    const isSelected = selected.includes(item.id);
+                                    return (_jsx("div", { onMouseEnter: e => {
+                                            openHover(e.currentTarget);
+                                            setHoverWords(item.words ?? []);
+                                        }, onMouseLeave: handleHoverLeave, children: _jsx(Button, { htmlType: "button", size: "word", align: "grid", label: (item.words ?? []).map(w => w.label), subLabel: (item.words ?? []).some(w => w.subLabel)
+                                                ? (item.words ?? []).map(w => w.subLabel)
+                                                : undefined, selected: isSelected, onClick: () => handleClick(item.id), minWidth: 200 }) }, item.id));
+                                }) })] }, group.label)))) : (_jsx("div", { className: "word-search-result-block__items", children: pagedItems.map((item) => {
                             const isSelected = selected.includes(item.id);
                             return (_jsx("div", { onMouseEnter: e => {
                                     openHover(e.currentTarget);

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

@@ -2,6 +2,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { getViableComposition, countUsableWords } from '../utils/wordTrainingRuntime';
+import { IMAGE_EXISTENCE_CACHE_UPDATED } from '../utils/imageConfig';
 import { FILTER_ALL_VALUE } from '../types/filterPanel';
 import { useWindowEvent } from './useWindowEvent';
 import { useWordAttributeFilterKeys, buildGradeSection, buildPartOfSpeechSection, buildWordTypeSection } from './useWordAttributeFilter';
@@ -236,6 +237,7 @@ export function useWordTrainingFilter(groupKey, caps, opts) {
     const [poolVersion, setPoolVersion] = useState(0);
     // 단어 풀 갱신 이벤트 구독
     useWindowEvent('wordpool:update', () => setPoolVersion(v => v + 1));
+    useWindowEvent(IMAGE_EXISTENCE_CACHE_UPDATED, () => setPoolVersion(v => v + 1));
     // 언어 전환 시에도 poolVersion을 올려 재생성을 트리거한다.
     // useWordTrainingDataGeneration의 batch 생성 effect는 (다른 렌더에서 매번 새 배열이 되는)
     // types를 의존성에서 의도적으로 제외하므로, types의 label/subTitle이 바뀌는 유일한 외부

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

@@ -470,7 +470,8 @@
             "measuring_duration": "Measuring length…",
             "ready": "Ready",
             "error": "Error",
-            "synthesizing": "Preparing the sound…"
+            "synthesizing": "Preparing the sound…",
+            "preparing": "Preparing sound…"
         }
     },
     "trainingSettings": {

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

@@ -462,7 +462,8 @@
             "measuring_duration": "오디오 길이 측정…",
             "ready": "준비 완료",
             "error": "오류 발생",
-            "synthesizing": "소리를 만들고 있습니다…"
+            "synthesizing": "소리를 만들고 있습니다…",
+            "preparing": "소리를 준비하고 있습니다…"
         }
     },
     "trainingSettings": {

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

@@ -19,14 +19,6 @@ 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/dailySelectionUtils.js

@@ -83,8 +83,10 @@ const DEFAULT_TRAINING_COUNTS = {
 // localStorage 캐시 없이 매번 결정적으로 재계산한다(저장 없음). 이웃한 두 날의 세트는 후보가 충분하면 겹치지 않는다(유형세트).
 export function resolveSelection(_forceRefresh = false, counts = DEFAULT_TRAINING_COUNTS, userId) {
     // 서버 완료집계와 동일하게 KST 기준 날짜. userId 없어도 날짜로 결정적(Math.random 비결정성 제거)
-    const today = toKstYmd(Date.now());
-    const yesterday = toKstYmd(Date.now() - 86400000);
+    // 한 순간에서 둘 다 계산한다. 두 번 시계를 읽는 사이 자정이 오면 오늘=어제가 된다.
+    const now = Date.now();
+    const today = toKstYmd(now);
+    const yesterday = toKstYmd(now - 86400000);
     const u = userId ?? '';
     const hasSource = NOISE_DATAS.length > 0 || SHORT_STORIES.length > 0 ||
         LONG_STORIES.length > 0 || ORDER_SETS.length > 0;

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

@@ -2,6 +2,8 @@
  * 날짜 포맷 유틸 — 산재한 Date 파싱 로직을 공유.
  * 각 화면의 표시 형식 차이는 옵션으로 흡수.
  */
+/** @internal 저장할 시각 문자열도 화면 표시와 같은 달력 검증을 사용한다. */
+export declare function isValidDateValue(when: string | number | Date): boolean;
 export declare function formatDateKo(iso: string): string;
 /** "2024년 1월 15일 오후 03:30" (long month + time) */
 export declare function formatDateLongKo(iso: string): string;

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

@@ -34,6 +34,14 @@ function toInstant(when) {
         d = when;
     else if (typeof when === 'string') {
         const s = when.trim();
+        // Date.parse는 없는 달력날도 다음 달로 굴린다(2월 30일 → 3월 2일).
+        // 표시 함수가 잘못된 원본을 실제 날짜처럼 보여 주지 않도록 날짜 부분을 먼저 확인한다.
+        const datePart = /^(\d{4}-\d{2}-\d{2})(?:$|[T ])/.exec(s)?.[1];
+        if (datePart) {
+            const calendarDate = new Date(`${datePart}T00:00:00Z`);
+            if (Number.isNaN(calendarDate.getTime()) || calendarDate.toISOString().slice(0, 10) !== datePart)
+                return null;
+        }
         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);
@@ -42,6 +50,10 @@ function toInstant(when) {
         d = new Date(when);
     return Number.isNaN(d.getTime()) ? null : d;
 }
+/** @internal 저장할 시각 문자열도 화면 표시와 같은 달력 검증을 사용한다. */
+export function isValidDateValue(when) {
+    return toInstant(when) !== null;
+}
 /* 못 읽는 값(빈 문자열·깨진 날짜)이면 null — 아래 형식 함수들이 화면에 "Invalid Date" 를 그대로 내던 것을 빈 글자로 막는다
    (같은 파일의 toKstYmd·formatYmd 는 이미 막고 있었다) */
 const parsed = (iso) => toInstant(iso);
@@ -164,7 +176,12 @@ export function getTodayKst() {
  * 공개 export 아님(utils.ts 가 다시 내보내지 않는다).
  */
 export function todayYmdOr(today) {
-    return today && /^\d{4}-\d{2}-\d{2}$/.test(today) ? today : getTodayKst();
+    if (today && /^\d{4}-\d{2}-\d{2}$/.test(today)) {
+        const date = toInstant(today);
+        if (date?.toISOString().slice(0, 10) === today)
+            return today;
+    }
+    return getTodayKst();
 }
 /**
  * KST 오늘을 **기기 달력의 자정 Date** 로 — 연·월·일 칸을 `getFullYear()/getMonth()/getDate()` 로 세는 곳(BarChart)의

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

@@ -5,6 +5,7 @@ declare global {
 export declare function configureImageResolver(resolver: (word: string, homonum?: number) => string): void;
 /** @public */
 export declare function getImageResolver(): ((word: string, homonum?: number) => string) | null;
+export declare const IMAGE_EXISTENCE_CACHE_UPDATED = "ihab:image-existence-updated";
 /**
  * @public
  * 단어 이미지 존재 여부 확인 — localStorage 캐시 우선, 없으면 HEAD 요청 후 캐시 저장.

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

@@ -10,6 +10,21 @@ export function getImageResolver() {
 }
 // ─── 로컬 캐싱 (localStorage + 메모리) ───────────────────────────────────────
 const LS_KEY = 'word_image_existence_map_v1';
+export const IMAGE_EXISTENCE_CACHE_UPDATED = 'ihab:image-existence-updated';
+let updatePending = null;
+function notifyCacheUpdated() {
+    if (updatePending !== null) {
+        clearTimeout(updatePending);
+        updatePending = null;
+    }
+    if (typeof window !== 'undefined')
+        window.dispatchEvent(new Event(IMAGE_EXISTENCE_CACHE_UPDATED));
+}
+function scheduleCacheUpdated() {
+    if (updatePending !== null)
+        return;
+    updatePending = setTimeout(notifyCacheUpdated, 200);
+}
 let memMap = null;
 /* 캐시가 바뀔 때마다 오르는 판 번호 — 통계·'있음' 낱말 집합을 판마다 한 번만 센다(단어훈련 칩 한 번에 유형 수만큼
    2.3만 칸을 훑었다). 캐시를 바꾸는 곳(확인 결과 담기·일괄 주입·비우기)은 모두 판을 올린다. */
@@ -111,7 +126,12 @@ async function probeImageExists(word, homonum, force = false) {
  * 한 번 확인된 단어는 영구 캐싱되어 다음 접속 시에도 즉시 반환.
  */
 export async function checkImageExists(word, homonum) {
-    return probeImageExists(word, homonum);
+    const before = cacheVersion;
+    const exists = await probeImageExists(word, homonum);
+    // 여러 단어를 동시에 확인하는 표에서도 이벤트를 한 번으로 모은다.
+    if (cacheVersion !== before)
+        scheduleCacheUpdated();
+    return exists;
 }
 /** @public 단어 이미지 존재 여부 동기 조회 (캐시에 있을 때만). 없으면 undefined. */
 export function getImageExistsCached(word, homonum) {
@@ -129,6 +149,7 @@ export function getImageExistsCached(word, homonum) {
 export async function prewarmImageCache(words, options = {}) {
     const { force = false, concurrency = 16, onProgress } = options;
     const map = ensureLoaded();
+    const before = cacheVersion;
     const todo = force ? Array.from(new Set(words)) : Array.from(new Set(words)).filter(w => !(keyOf(w) in map));
     let done = 0;
     if (todo.length > 0) {
@@ -161,6 +182,9 @@ export async function prewarmImageCache(words, options = {}) {
         }
     }
     catch { }
+    // 병렬 HEAD마다 알리면 대량 사전 확인 중 필터가 수천 번 재계산된다.
+    if (cacheVersion !== before)
+        notifyCacheUpdated();
     return { checked: todo.length, cached: Object.keys(map).length, total: words.length };
 }
 /**
@@ -208,6 +232,7 @@ export function bulkSetImageExistence(entries) {
         }
     }
     catch { }
+    notifyCacheUpdated();
 }
 /** @public 캐시 초기화 (이미지 데이터 변경 시 호출) */
 export function clearImageExistenceCache() {
@@ -223,4 +248,5 @@ export function clearImageExistenceCache() {
             localStorage.removeItem(LS_KEY);
     }
     catch { }
+    notifyCacheUpdated();
 }

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

@@ -16,7 +16,7 @@ function decompose(char) {
 /* 음절 자리 코드는 **아래 모듈**에 있다 — `phonemeConvert` 도 함께 쓰는데, 여기 두면
    `phonemePairSearch ↔ phonemeConvert` 돌림 import 가 된다(한 번 그렇게 해 시험 338 꾸러미가
    무너졌다, 2026-10-13). */
-import { toPhonemeCodes, toLegacyPhonemeKey, isPhonemeSectionCode, PHONEME_SECTION_CODES, PHONEME_NONE } from './phonemeSectionCodes';
+import { toPhonemeCodes, isPhonemeSectionCode, PHONEME_SECTION_CODES, PHONEME_NONE } from './phonemeSectionCodes';
 export { toPhonemeCodes, PHONEME_NONE } from './phonemeSectionCodes';
 const SECTION_KEYS = PHONEME_SECTION_CODES;
 const NONE = PHONEME_NONE;
@@ -444,8 +444,6 @@ function searchPairsCore(selectedList, words, debug, enforcePosition, phonemic =
                     for (const sec of senses.get(second) ?? [second]) {
                         results.push({
                             id: `${wordKey(f)}|${wordKey(sec)}`,
-                            /* 옛 이름을 내보내고 코드를 나란히 — 소비자가 옛 값으로 묶음을 가른다 */
-                            diffSection: toLegacyPhonemeKey(sDiffSection),
                             diffSectionCode: sDiffSection,
                             diffHasEmpty: sDiffHasEmpty,
                             words: [wordCells(f), wordCells(sec)],
@@ -689,7 +687,6 @@ preferAsTarget) {
                 const kt = wordKey(t), kc = wordKey(c);
                 results.push({
                     id: kt < kc ? `${kt}|${kc}` : `${kc}|${kt}`,
-                    diffSection: toLegacyPhonemeKey(item.diffSection),
                     diffSectionCode: item.diffSection,
                     diffHasEmpty: item.diffHasEmpty,
                     words: [wordCells(t), wordCells(c)],

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

@@ -1,20 +1,3 @@
-/**
- * 훈련 한 판의 **문항 하나하나**를 기록할 수 있는 모양으로 추린다.
- *
- * 08-26 회의에서 치료사가 "음소별 오류를 보고 싶다"고 했다. 그러려면 어느 낱말을
- * 틀렸는지가 남아야 하는데, 지금은 안 남는다 — `customer_training_result` 의
- * `item_id`·`item_title` 이 전부 null 이다.
- *
- * 정보가 없어서가 아니다. 훈련이 끝나는 순간 화면은 문항마다
- * `{ question, choices, selected, selectedText, correct, answer }` 를 들고 있다
- * (trainingPopupUtils 의 build*Results). 그걸 `correct/total` 두 숫자로 접어서 버리고
- * 있었다. 접기 전에 한 번 추려 둔다.
- *
- * **음소를 여기서 뽑지 않는다.** 낱말을 남기는 것과 그 낱말에서 음소를 세는 것은 다른
- * 일이고, 뒤엣것은 아직 규칙이 정해지지 않았다(어두/어중/어말 위치 모델도 바뀌는 중이다).
- * 지금 섣불리 음소를 박아 두면, 규칙이 바뀔 때 이미 쌓인 기록이 옛 규칙으로 남는다.
- * 낱말은 사실이고 음소는 해석이다 — 사실만 남긴다.
- */
 /** @public 훈련 한 문항의 결과 — 서버에 남길 만큼만 추린 것 */
 export interface TrainingItemResult {
     /** 몇 번째 문항인가(0부터) — 같은 낱말이 두 번 나와도 구별된다 */

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

@@ -15,6 +15,7 @@
  * 지금 섣불리 음소를 박아 두면, 규칙이 바뀔 때 이미 쌓인 기록이 옛 규칙으로 남는다.
  * 낱말은 사실이고 음소는 해석이다 — 사실만 남긴다.
  */
+import { isValidDateValue } from './date';
 /**
  * 때 하나 — ISO 8601 글자로 남긴다. 못 읽는 값은 `null`(없는 때를 지어내지 않는다).
  *
@@ -29,7 +30,7 @@ function timeOf(v) {
         const s = v.trim();
         if (!s)
             return null;
-        return Number.isNaN(new Date(s).getTime()) ? null : s;
+        return isValidDateValue(s) ? s : null;
     }
     if (v instanceof Date)
         return Number.isNaN(v.getTime()) ? null : v.toISOString();

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

@@ -57,16 +57,14 @@ function saveToLocalStorage(index, sig) {
     }
     catch { }
 }
-/** 입력의 signature 계산 (단어+발음 해시) — 캐시 무효화에 사용 */
+/** 입력의 signature 계산 (단어+발음 해시) — 첫 유효 중복 행을 쓰므로 입력 순서도 포함한다. */
 function computeSig(items) {
-    const sorted = items.map(it => `${it.word}|${it.pron ?? ''}`).sort();
+    const serialized = JSON.stringify(items.map(it => [it.word, it.pron ?? '']));
     let h = 0;
-    for (const s of sorted) {
-        for (let i = 0; i < s.length; i++) {
-            h = ((h << 5) - h + s.charCodeAt(i)) | 0;
-        }
+    for (let i = 0; i < serialized.length; i++) {
+        h = ((h << 5) - h + serialized.charCodeAt(i)) | 0;
     }
-    return `${sorted.length}-${h}`;
+    return `${items.length}-${h}`;
 }
 async function buildIndexAsync(items, onProgress) {
     // 단어(철자) 기준 중복 제거하되, 대립 비교는 표준발음을 분해해서 수행한다.

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

@@ -158,13 +158,18 @@ export function filterByCachedImage(words) {
 const _poolCache = new Map();
 let _cachePoolRef = null;
 let _cacheIdxRef = null;
+let _cacheImageOkRef = null;
 function _jamoKey(v) {
     if (v == null)
         return '';
     return Array.isArray(v) ? v.slice().sort().join(',') : v;
 }
 export function _poolCacheKey(opts) {
-    const chStr = _jamoKey(opts.choseong);
+    // choseong=[] 은 후보를 전부 제외한다. 미지정(무제약)과 같은 키로 묶으면
+    // 먼저 계산한 쪽의 결과가 다른 조건에 재사용된다.
+    const chStr = Array.isArray(opts.choseong) && opts.choseong.length === 0
+        ? '[]'
+        : _jamoKey(opts.choseong);
     const c = opts.composition;
     const sylKey = c?.syllable == null ? '' : (Array.isArray(c.syllable) ? c.syllable.slice().sort().join(',') : String(c.syllable));
     const compStr = c ? `${_jamoKey(c.cho)}/${_jamoKey(c.jung)}/${_jamoKey(c.jong)}/${c.jongNone ? 'N' : ''}/${sylKey}` : '';
@@ -201,11 +206,15 @@ export async function buildUsablePool(opts) {
     // wordPool/pairIndex가 교체되면 캐시 전체 무효화
     const pool = getWordPool();
     const idx = getPairIndex();
-    if (pool !== _cachePoolRef || idx !== _cacheIdxRef) {
+    // 이미지 필터의 결과는 풀 참조를 바꾸지 않고도 prewarm/일괄 주입 중 달라진다.
+    // getImageOkWordSet은 캐시 판이 바뀔 때 새 Set을 돌려주므로 이를 무효화 기준으로 쓴다.
+    const imageOkRef = opts.excludeNoImage ? getImageOkWordSet() : null;
+    if (pool !== _cachePoolRef || idx !== _cacheIdxRef || (opts.excludeNoImage && imageOkRef !== _cacheImageOkRef)) {
         _poolCache.clear();
         _posContrastCache.clear();
         _cachePoolRef = pool;
         _cacheIdxRef = idx;
+        _cacheImageOkRef = imageOkRef;
     }
     const key = _poolCacheKey(opts);
     if (!_poolCache.has(key))

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

@@ -10,6 +10,7 @@
  * @public
  */
 import { getWordPool } from './wordPool';
+import { getImageOkWordSet } from './imageConfig';
 import { shuffle } from './array';
 import { getPairIndex } from './wordPairIndex';
 import { wordContainsPhoneme, syllableLength, parseSyllable, CHOSEONG, JUNGSEONG, JONGSEONG, JONG_DECOMPOSE } from './koreanSyllable';
@@ -165,7 +166,7 @@ async function genStartsWithSame(opts) {
     }
     // sourceWord 와 correct 가 모두 필요하므로 같은 첫음절 단어 ≥2개인 그룹만 사용
     const viableFirsts = Object.entries(sameFirstPool)
-        .filter(([, ws]) => ws.length >= 2)
+        .filter(([, ws]) => new Set(ws.map(w => wordPron.get(w) || w)).size >= 2)
         .map(([f]) => f);
     if (viableFirsts.length === 0)
         return [];
@@ -176,15 +177,13 @@ async function genStartsWithSame(opts) {
         const group = sameFirstPool[targetSyllable];
         if (group.length < 2)
             continue;
-        // sourceWord 와 correct 는 같은 그룹에서 서로 다른 단어
+        // sourceWord 와 correct 는 같은 그룹에서 소리도 달라야 한다. 앞의 두 낱말이
+        // 동음어여도 유효한 다른 짝이 있으면 그 짝을 선택한다.
         const picked = shuffle([...group]);
         const sourceWord = picked[0];
-        const correct = picked[1];
-        // 명시적 동일 단어 방지. 표기가 달라도 발음이 같으면(깜박/깜빡 → 둘 다 '깜빡') 정답 카드가
-        // 문제 소리와 완전히 똑같이 들려 변별 과제가 성립하지 않으므로 발음 동일도 배제한다.
-        if (!sourceWord || !correct || sourceWord === correct)
-            continue;
-        if ((wordPron.get(sourceWord) || sourceWord) === (wordPron.get(correct) || correct))
+        const sourcePron = wordPron.get(sourceWord) || sourceWord;
+        const correct = picked.find(w => w !== sourceWord && (wordPron.get(w) || w) !== sourcePron);
+        if (!sourceWord || !correct)
             continue;
         // 오답: 첫 음절(발음)이 다르고, 정답(correct)과 음절수(글자수)가 같으며, 발음이 다른 단어 (sourceWord, correct 모두 제외)
         // 철자 첫 글자로 거르면 '학교(학꾜)'가 targetSyllable '하'인 문제의 오답으로 뽑혀
@@ -579,20 +578,28 @@ function genRemoveConsonant(opts) {
 const _resultCache = new Map();
 let _resultCachePoolRef = null;
 let _resultCacheIdxRef = null;
+let _resultCacheImageOkRef = null;
+let _resultCacheEpoch = 0;
 /** @public 훈련 유형별 문제 item 생성 */
 export async function generateRuntimeItems(typeKey, opts = {}) {
     const pool = getWordPool();
     const idx = getPairIndex();
-    if (pool !== _resultCachePoolRef || idx !== _resultCacheIdxRef) {
+    const imageOkRef = opts.excludeNoImage ? getImageOkWordSet() : null;
+    if (pool !== _resultCachePoolRef || idx !== _resultCacheIdxRef || (opts.excludeNoImage && imageOkRef !== _resultCacheImageOkRef)) {
         _resultCache.clear();
+        _resultCacheEpoch++;
         _resultCachePoolRef = pool;
         _resultCacheIdxRef = idx;
+        _resultCacheImageOkRef = imageOkRef;
     }
     const cacheKey = `${typeKey}:${_poolCacheKey(opts)}`;
     if (_resultCache.has(cacheKey))
         return _resultCache.get(cacheKey);
+    const epoch = _resultCacheEpoch;
     const items = await _generateRuntimeItems(typeKey, opts);
-    _resultCache.set(cacheKey, items);
+    // 계산 중 풀이나 이미지 캐시가 교체됐다면 늦게 끝난 옛 문항을 새 캐시에 다시 넣지 않는다.
+    if (epoch === _resultCacheEpoch)
+        _resultCache.set(cacheKey, items);
     return items;
 }
 const GENERATOR_MAP = {
@@ -656,7 +663,9 @@ export async function precomputeCommonCombinations(excludeNoImage) {
 }
 /** @public 이미지/난이도 조건이 적용된 초성 set — pool 단어 어디든 해당 자모가 있으면 viable */
 export async function getViableChoseongs(opts = {}) {
-    const pool = await buildUsablePool({ difficulty: opts.difficulty ?? null, excludeNoImage: opts.excludeNoImage });
+    // 선택 가능 여부는 전체 후보 기준이어야 한다. 생성용 샘플 캡(기본 1500)을 쓰면
+    // 샘플 밖의 드문 초성이 실제로 가능해도 버튼에서 사라진다.
+    const pool = await buildUsablePool({ difficulty: opts.difficulty ?? null, excludeNoImage: opts.excludeNoImage, fullCount: true });
     const set = new Set();
     // 모든 19 초성 자모를 단어와 매칭해서 viable 검사
     const allJamos = ['ㄱ', 'ㄲ', 'ㄴ', 'ㄷ', 'ㄸ', 'ㄹ', 'ㅁ', 'ㅂ', 'ㅃ', 'ㅅ', 'ㅆ', 'ㅇ', 'ㅈ', 'ㅉ', 'ㅊ', 'ㅋ', 'ㅌ', 'ㅍ', 'ㅎ'];

package/dist/packages/core/src/version.d.ts

@@ -46,4 +46,4 @@
  *
  * 값은 손으로 적고 `test/coreVersion.test.ts` 가 package.json 과 어긋나면 운다.
  */
-export declare const CORE_VERSION = "0.344.0";
+export declare const CORE_VERSION = "0.346.0";

package/dist/packages/core/src/version.js

@@ -46,4 +46,4 @@
  *
  * 값은 손으로 적고 `test/coreVersion.test.ts` 가 package.json 과 어긋나면 운다.
  */
-export const CORE_VERSION = '0.344.0';
+export const CORE_VERSION = '0.346.0';