@ihabdevteam/core 0.152.0 → 0.154.0

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

@@ -836,6 +836,11 @@
             "pronoun": "대명사",
             "auxVerb": "보조동사",
             "auxAdjective": "보조형용사"
+        },
+        "reorder": {
+            "moved": "{{total}}칸 가운데 {{n}}번째로 옮김",
+            "handle": "{{word}} 순서 바꾸기 (Alt + 화살표)",
+            "hint": "Alt + ← → 로 순서 바꾸기"
         }
     },
     "wordSearch": {

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

@@ -72,6 +72,7 @@ import GamepadIcon from 'lucide-react/dist/esm/icons/gamepad.mjs';
 import GavelIcon from 'lucide-react/dist/esm/icons/gavel.mjs';
 import GitMergeIcon from 'lucide-react/dist/esm/icons/git-merge.mjs';
 import GlobeIcon from 'lucide-react/dist/esm/icons/globe.mjs';
+import GripVerticalIcon from 'lucide-react/dist/esm/icons/grip-vertical.mjs';
 import HeadphonesIcon from 'lucide-react/dist/esm/icons/headphones.mjs';
 import HeartIcon from 'lucide-react/dist/esm/icons/heart.mjs';
 import HomeIcon from 'lucide-react/dist/esm/icons/home.mjs';
@@ -256,6 +257,7 @@ export const STATIC_LUCIDE_ICONS = {
     'gavel': GavelIcon,
     'git-merge': GitMergeIcon,
     'globe': GlobeIcon,
+    'grip-vertical': GripVerticalIcon,
     'headphones': HeadphonesIcon,
     'heart': HeartIcon,
     'home': HomeIcon,

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

@@ -324,10 +324,10 @@ function searchPairsCore(selectedList, words, debug, enforcePosition, phonemic =
         return Number.isFinite(parsed) ? parsed : 99;
     };
     const groups = new Map();
+    /* 표기가 같아도 뜻마다 칸이 하나다 — 판정은 대표로 한 번만 하고 결과에서 뜻을 펼친다 */
+    const { 대표들, 뜻들 } = 뜻묶기(words);
     const seenWords = new Set();
-    for (const entry of words) {
-        if (seenWords.has(entry.word))
-            continue;
+    for (const entry of 대표들) {
         seenWords.add(entry.word);
         const decomposeFn = phonemic ? decomposePhonemicSyllable : decompose;
         const syllables = [...cleanPron(entry.pronunciation)].map(decomposeFn);
@@ -381,15 +381,17 @@ function searchPairsCore(selectedList, words, debug, enforcePosition, phonemic =
                 const sDiffSection = Object.keys(analysis.diff.diffs)[0];
                 const sDiffVals = analysis.diff.diffs[sDiffSection];
                 const sDiffHasEmpty = diffHasEmptyPair(sDiffSection, sDiffVals);
-                results.push({
-                    id: `${first.word}|${second.word}`,
-                    diffSection: sDiffSection,
-                    diffHasEmpty: sDiffHasEmpty,
-                    words: [
-                        { label: first.word, subLabel: first.pronunciation, colloquialLabel: first.colloquialPronunciation, homonum: first.homonum, grade: first.grade, syllables: [...first.word].length, pos: first.pos, wordType: first.wordType, isCustom: first.isCustom },
-                        { label: second.word, subLabel: second.pronunciation, colloquialLabel: second.colloquialPronunciation, homonum: second.homonum, grade: second.grade, syllables: [...second.word].length, pos: second.pos, wordType: second.wordType, isCustom: second.isCustom },
-                    ],
-                });
+                // 뜻마다 한 칸 — '눈'(신체)·'눈'(날씨) 가 각각 '문' 과 쌍을 이룬다
+                for (const f of 뜻들.get(first) ?? [first]) {
+                    for (const sec of 뜻들.get(second) ?? [second]) {
+                        results.push({
+                            id: `${낱말열쇠(f)}|${낱말열쇠(sec)}`,
+                            diffSection: sDiffSection,
+                            diffHasEmpty: sDiffHasEmpty,
+                            words: [낱말칸(f), 낱말칸(sec)],
+                        });
+                    }
+                }
             }
         }
     }
@@ -426,6 +428,41 @@ export function searchPairs(selectedList, words, enforcePosition, phonemic = fal
 }
 // ── 포함 검색: 음소를 모두 포함하는 단어의 대립쌍 ─────────────
 // 슬롯 i → 단어의 i번째 음절에 조건 매칭 (순서 보장)
+/** 표기가 같아도 뜻이 다르면 다른 칸 — 칸에 붙는 그림이 뜻마다 다르다(사용자 결정 2026-09-16).
+ *  동음이의 번호가 없는 자료는 예전처럼 표기뿐이다. */
+function 낱말열쇠(entry) {
+    return entry.homonum != null ? `${entry.word}#${entry.homonum}` : entry.word;
+}
+/** 표기·발음이 같은 뜻들을 한 대표로 묶는다 — 최소대립쌍 판정은 표기와 발음만 보므로 뜻마다 다시 셀 까닭이 없다.
+ *  (뜻을 모두 후보로 넣으면 묶음이 커져 23,000 낱말에서 검색이 2–4배 느려졌다.) 결과를 만들 때 뜻마다 칸을 펼친다. */
+/** 결과 칸 하나 */
+function 낱말칸(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 대표들 = [];
+    for (const entry of words) {
+        const 열쇠 = `${entry.word}\u0000${cleanPron(entry.pronunciation)}`;
+        const 대표 = 자리.get(열쇠);
+        if (대표 === undefined) {
+            자리.set(열쇠, entry);
+            대표들.push(entry);
+            뜻들.set(entry, [entry]);
+            continue;
+        }
+        const 목록 = 뜻들.get(대표);
+        // 같은 번호가 두 번 오면(자료 중복) 한 번만
+        if (목록.some(e => 낱말열쇠(e) === 낱말열쇠(entry)))
+            continue;
+        목록.push(entry);
+    }
+    return { 대표들, 뜻들 };
+}
 function wordContainsAllPhonemes(syllables, requirements) {
     for (let i = 0; i < requirements.length; i++) {
         const entries = Object.entries(requirements[i]).filter(([k]) => isSectionKey(k));
@@ -467,10 +504,9 @@ preferAsTarget) {
     const makeKey = (syls, pos) => syls.map((s, i) => (i === pos ? '*' : encodeAll(s))).join('|');
     const decomposeFn = phonemic ? decomposePhonemicSyllable : decompose;
     const allWords = [];
+    const { 대표들, 뜻들 } = 뜻묶기(words);
     const seenWords = new Set();
-    for (const entry of words) {
-        if (seenWords.has(entry.word))
-            continue;
+    for (const entry of 대표들) {
         seenWords.add(entry.word);
         const syls = [...cleanPron(entry.pronunciation)].map(decomposeFn);
         if (syls.some(s => s === null))
@@ -500,8 +536,8 @@ preferAsTarget) {
             groups.get(key).push(w);
         }
     }
-    const results = [];
-    // dedupKey → results 배열 내 인덱스. 같은 두 단어가 서로 minimal pair이면서
+    const 쌍들 = [];
+    // dedupKey → 쌍들 배열 내 인덱스. 같은 두 단어가 서로 minimal pair이면서
     // 둘 다 독립적으로 targetWords에 속할 수 있어(예: 다른 음절에 요구 음소가 하나 더 있는 경우),
     // 어느 쪽을 target(1번/words[0])으로 채택할지가 순회 순서에 좌우될 수 있다.
     // preferAsTarget이 주어지면(예: "검색 단어만" 필터) 그 조건을 만족하는 방향을 우선한다.
@@ -537,7 +573,7 @@ preferAsTarget) {
                 if (existingIdx !== undefined) {
                     if (!preferAsTarget)
                         continue;
-                    if (preferAsTarget(results[existingIdx].words[0]))
+                    if (preferAsTarget(낱말칸(쌍들[existingIdx].target)))
                         continue;
                     if (!preferAsTarget({ grade: target.entry.grade, syllables: [...target.entry.word].length, pos: target.entry.pos, wordType: target.entry.wordType }))
                         continue;
@@ -572,47 +608,32 @@ preferAsTarget) {
                 const diffSection = Object.keys(analysis.diff.diffs)[0];
                 const diffVals = analysis.diff.diffs[diffSection];
                 const diffHasEmpty = diffHasEmptyPair(diffSection, diffVals);
-                const item = {
-                    /* 정렬 꼴 그대로 — 기준 방향을 넣으면 음소를 ㄱ→ㄴ 으로 바꿔 찾거나 저장한 표를 다시 열 때 같은 쌍의 id 가 달라져
-                       바구니(id 로 견줌)에서 선택이 풀리고 두 번 담겼다. 이미 저장된 대립쌍표 id 도 이 꼴이다. */
-                    id: dedupKey,
-                    diffSection,
-                    diffHasEmpty,
-                    words: [
-                        {
-                            label: target.entry.word,
-                            subLabel: target.entry.pronunciation,
-                            colloquialLabel: target.entry.colloquialPronunciation,
-                            homonum: target.entry.homonum,
-                            grade: target.entry.grade,
-                            syllables: [...target.entry.word].length,
-                            pos: target.entry.pos,
-                            wordType: target.entry.wordType,
-                            isCustom: target.entry.isCustom,
-                        },
-                        {
-                            label: candidate.entry.word,
-                            subLabel: candidate.entry.pronunciation,
-                            colloquialLabel: candidate.entry.colloquialPronunciation,
-                            homonum: candidate.entry.homonum,
-                            grade: candidate.entry.grade,
-                            syllables: [...candidate.entry.word].length,
-                            pos: candidate.entry.pos,
-                            wordType: candidate.entry.wordType,
-                            isCustom: candidate.entry.isCustom,
-                        },
-                    ],
-                };
+                const item = { target: target.entry, candidate: candidate.entry, diffSection, diffHasEmpty };
                 if (existingIdx !== undefined) {
-                    results[existingIdx] = item;
+                    쌍들[existingIdx] = item;
                 }
                 else {
-                    seenPairs.set(dedupKey, results.length);
-                    results.push(item);
+                    seenPairs.set(dedupKey, 쌍들.length);
+                    쌍들.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);
+                results.push({
+                    id: kt < kc ? `${kt}|${kc}` : `${kc}|${kt}`,
+                    diffSection: 것.diffSection,
+                    diffHasEmpty: 것.diffHasEmpty,
+                    words: [낱말칸(t), 낱말칸(c)],
+                });
+            }
+        }
+    }
     const gradeOrder = (g) => {
         const parsed = Number.parseInt(g ?? '', 10);
         return Number.isFinite(parsed) ? parsed : 99;

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

@@ -5,6 +5,15 @@ export interface PlanFeatures {
     maxCustomers: number;
     visitWord: boolean;
     visitSentence: boolean;
+    /**
+     * 숙제내주기(쿠폰) — **노출 여부만** 말한다.
+     *
+     * 하루 몇 번 보낼 수 있는지는 `PLAN_LIMITS[tier].homeworkSendDaily` 가 정본이고,
+     * 어드민 요금제 비교표의 '숙제 보내기' 칸도 그 숫자로 그린다. 이 플래그는 그 숫자가
+     * 있는 티어에서 켜져 있어야 한다 — 전에는 mgr_free·lite·standard 가 하루 1·10·30회를
+     * 받으면서도 false 라, 같은 화면이 한 칸에서는 횟수를 말하고 옆 칸에서는 ✗ 를 말했다
+     * (사용자 결정 2026-09-16). 숫자를 고칠 때는 이 플래그도 같이 본다.
+     */
     homework: boolean;
     customerStats: boolean;
     managerCustomerSplit: boolean;
@@ -32,8 +41,26 @@ export interface PlanFeatures {
     sentenceTrainingView: boolean;
 }
 export declare const PLAN_FEATURES: Record<PlanTier, PlanFeatures>;
-/** 요금제 티어 순위 (높을수록 상위 요금제) */
+/**
+ * 요금제 티어 순위 — **같은 줄 안에서 견주는 값**이다(클수록 상위 요금제).
+ *
+ * 줄마다 자리를 갈라 둔다: 개인 줄 0~9, 매니저 줄 10~19. 전에는 한 자리에 섞여 있어
+ * (personal_standard 3 < mgr_free 4) 줄이 다른 두 티어의 순위 차가 무슨 뜻인지 읽을 수
+ * 없었다(사용자 결정 2026-09-16). 줄이 같은지는 `isManagerTier` 로 본다.
+ *
+ * 줄 사이의 크기 비교(매니저 줄이 개인 줄보다 큼)는 전과 같은 방향이라, 활성 구독 중
+ * 가장 높은 티어를 고르는 코드는 그대로 동작한다 — 다만 그런 비교는 "매니저 줄이
+ * 개인 줄보다 상위"라는 뜻이지 기능 수의 많고 적음이 아니다.
+ * 레거시 라이트(낱말·문장)는 서로 대등해 같은 자리를 쓴다.
+ */
 export declare const TIER_RANK: Record<PlanTier, number>;
+/**
+ * @public 티어가 매니저 줄(말귀매니저)인지. `none` 과 개인 줄(free·personal_standard)은 false.
+ *
+ * 요금제 비교표처럼 "이 칸은 매니저 플랜에만 있다" 를 그리는 곳이 티어 목록을 손으로
+ * 들고 있지 않도록 여기서 내준다 — 티어가 늘면 그 목록만 뒤처진다.
+ */
+export declare function isManagerTier(tier: PlanTier): boolean;
 /**
  * 요금제별 수량/횟수 제한.
  *

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

@@ -27,7 +27,7 @@ export const PLAN_FEATURES = {
     },
     // ── 매니저 플랜 ─────────────────────────────────────────────────
     mgr_free: {
-        maxCustomers: 5, visitWord: true, visitSentence: true, homework: false,
+        maxCustomers: 5, visitWord: true, visitSentence: true, homework: true,
         customerStats: false, managerCustomerSplit: false, managerManagement: false,
         sentenceTrainingSetting: false, wordTrainingSetting: false, myWordList: false,
         wordListShare: false, groupTrainingSetting: false, minimalPairSearch: true,
@@ -75,7 +75,7 @@ export const PLAN_FEATURES = {
         sentenceTrainingView: true,
     },
     lite: {
-        maxCustomers: 10, visitWord: true, visitSentence: true, homework: false,
+        maxCustomers: 10, visitWord: true, visitSentence: true, homework: true,
         customerStats: false, managerCustomerSplit: false, managerManagement: false,
         sentenceTrainingSetting: false, wordTrainingSetting: false, myWordList: false,
         wordListShare: false, groupTrainingSetting: false, minimalPairSearch: true,
@@ -87,7 +87,7 @@ export const PLAN_FEATURES = {
         sentenceTrainingView: true,
     },
     standard: {
-        maxCustomers: 30, visitWord: true, visitSentence: true, homework: false,
+        maxCustomers: 30, visitWord: true, visitSentence: true, homework: true,
         customerStats: false, managerCustomerSplit: false, managerManagement: false,
         sentenceTrainingSetting: true, wordTrainingSetting: true, myWordList: true,
         wordListShare: true, groupTrainingSetting: false, minimalPairSearch: true,
@@ -123,14 +123,44 @@ export const PLAN_FEATURES = {
         sentenceTrainingView: true,
     },
 };
-/** 요금제 티어 순위 (높을수록 상위 요금제) */
+/**
+ * 요금제 티어 순위 — **같은 줄 안에서 견주는 값**이다(클수록 상위 요금제).
+ *
+ * 줄마다 자리를 갈라 둔다: 개인 줄 0~9, 매니저 줄 10~19. 전에는 한 자리에 섞여 있어
+ * (personal_standard 3 < mgr_free 4) 줄이 다른 두 티어의 순위 차가 무슨 뜻인지 읽을 수
+ * 없었다(사용자 결정 2026-09-16). 줄이 같은지는 `isManagerTier` 로 본다.
+ *
+ * 줄 사이의 크기 비교(매니저 줄이 개인 줄보다 큼)는 전과 같은 방향이라, 활성 구독 중
+ * 가장 높은 티어를 고르는 코드는 그대로 동작한다 — 다만 그런 비교는 "매니저 줄이
+ * 개인 줄보다 상위"라는 뜻이지 기능 수의 많고 적음이 아니다.
+ * 레거시 라이트(낱말·문장)는 서로 대등해 같은 자리를 쓴다.
+ */
 export const TIER_RANK = {
+    // ── 개인 줄 ──
     none: 0,
-    free: 1, personal_standard: 3,
-    mgr_free: 4,
-    lite_word: 5, lite_sentence: 5, lite: 6,
-    standard: 7, pro: 8, enterprise: 9,
+    free: 1,
+    personal_standard: 2,
+    // ── 매니저 줄 ──
+    mgr_free: 10,
+    lite_word: 11, lite_sentence: 11,
+    lite: 12,
+    standard: 13,
+    pro: 14,
+    enterprise: 15,
 };
+/** 매니저 줄(말귀매니저) 티어들 — TIER_RANK 의 10번대와 같은 집합이다. */
+const MANAGER_TIERS = new Set([
+    'mgr_free', 'lite_word', 'lite_sentence', 'lite', 'standard', 'pro', 'enterprise',
+]);
+/**
+ * @public 티어가 매니저 줄(말귀매니저)인지. `none` 과 개인 줄(free·personal_standard)은 false.
+ *
+ * 요금제 비교표처럼 "이 칸은 매니저 플랜에만 있다" 를 그리는 곳이 티어 목록을 손으로
+ * 들고 있지 않도록 여기서 내준다 — 티어가 늘면 그 목록만 뒤처진다.
+ */
+export function isManagerTier(tier) {
+    return MANAGER_TIERS.has(tier);
+}
 /** @public 요금제 티어별 제한 (표시되지 않는 레거시 티어는 생략) */
 export const PLAN_LIMITS = {
     // ── 개인 ──

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

@@ -173,6 +173,25 @@ export function _poolCacheKey(opts) {
     // 요청한 보기 수를 무시한다(공개 API 라 앱 밖 호출자가 무엇을 넘길지 알 수 없다).
     return `${opts.difficulty ?? ''}|${chStr}|${compStr}|${opts.excludeNoImage ? '1' : '0'}|${opts.count ?? ''}|x${opts.contrastCount ?? 1}|${opts.fullCount ? 'F' : ''}|s${opts.sameStructureOnly === false ? '0' : '1'}|v${opts.phonemeView === 'pron' ? 'p' : 'c'}|g${gradeStr}|t${opts.targetSyllable ?? ''}|c${opts.choicesPerItem ?? ''}`;
 }
+/**
+ * 위치 대립 맵 캐시 — 칩 한 번에 **셈(fullCount)과 생성이 같은 맵을 따로** 만들었다.
+ *
+ * 맵은 재료(이미지 필터를 지난 낱말 전체)와 고른 음소·구조 조건만으로 정해지는 결정적인
+ * 값이고, 셈과 생성은 그 둘이 똑같다(fullCount 는 후보 샘플링 캡에만 관여한다). 그래서 둘이
+ * 나눠 쓴다 — 23,000 낱말에서 칩 한 번이 256ms → 93ms(사용자 결정 2026-09-16).
+ *
+ * 열쇠는 풀 캐시 열쇠에서 **맵과 무관한 것**(문제 수·보기 수·fullCount)만 뺀 것이다. 재료를
+ * 바꾸는 것(난이도·초성·구성·등급·기준 글자·이미지 제외)은 모두 열쇠에 남아 있어야 한다 —
+ * 하나라도 빠지면 다른 설정의 답을 그대로 돌려준다.
+ *
+ * 이미지 제외를 켠 경우엔 열쇠만으로 모자란다 — '이미지 있음' 캐시는 미리 데우는 동안 풀
+ * 참조가 그대로인 채로 자란다(셈과 생성 사이에도 자랄 수 있다). 그래서 맵을 만들 때 쓴
+ * 낱말 집합을 함께 들고 있다가, 그 집합이 갈리면 다시 만든다.
+ */
+const _posContrastCache = new Map();
+function _posContrastCacheKey(opts) {
+    return _poolCacheKey({ ...opts, count: undefined, choicesPerItem: undefined, fullCount: false });
+}
 /**
  * 기준 글자/난이도/이미지 조건을 모두 통과한 (본 단어 + 유효 distractor) 풀을 만든다.
  * @returns [{ word: 본단어, usable: 이미지 OK + 난이도 매칭 distractor 배열 }]
@@ -183,6 +202,7 @@ export async function buildUsablePool(opts) {
     const idx = getPairIndex();
     if (pool !== _cachePoolRef || idx !== _cacheIdxRef) {
         _poolCache.clear();
+        _posContrastCache.clear();
         _cachePoolRef = pool;
         _cacheIdxRef = idx;
     }
@@ -392,9 +412,17 @@ async function _buildUsablePool(opts) {
     const decompOf = createDecompCache(); // 호출당 새 캐시(이 생성 함수 스코프에 한정)
     // 위치 대립: 전체 풀에서 완전 사전계산(마스킹 템플릿 인덱스). 후보당 O(1) 조회.
     // 단일/다중 파트 모두 이 경로로 처리 — pairIndex 는 겹받침 단어(예: 값)를 누락하므로 의존하지 않는다.
-    const posContrastMap = posContrast
-        ? buildMultiPartPosContrast(composition, allOkArr, decompOf, sameStructureOnly, phonemeView, pronOfWord)
-        : null;
+    // 셈(fullCount)과 생성이 같은 맵을 쓴다(_posContrastCache) — 읽기만 하므로 공유해도 안전하다.
+    let posContrastMap = null;
+    if (posContrast) {
+        const mapKey = _posContrastCacheKey(opts);
+        const 이미지집합 = excludeNoImage ? getImageOkWordSet() : null;
+        const 전 = _posContrastCache.get(mapKey);
+        posContrastMap = 전 && 전.이미지집합 === 이미지집합
+            ? 전.map
+            : buildMultiPartPosContrast(composition, allOkArr, decompOf, sameStructureOnly, phonemeView, pronOfWord);
+        _posContrastCache.set(mapKey, { 이미지집합, map: posContrastMap });
+    }
     // candidates 크기 제한 — 이미지 필터 이후이므로 okCandidates 기반
     const RANDOM_CAND_CAP = 500; // random: classifyPairDifficulty 없으나 루프 자체 제한
     const OTHER_CAND_CAP = 1500; // cho/jung/jong: classifyPairDifficulty 호출이 있으므로 더 엄격히

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

@@ -53,6 +53,6 @@ export type { WordEntry } from './utils/phonemePairSearch';
 export { CAPABILITY, isValidQuestionWord, hasQuestionWordConstraint, isManualOnlyType } from './utils/wordTrainingRuntime';
 export { wordContainsChoseong, wordContainsJungseong, wordContainsJongseong, wordHasNoCoda, wordHasSyllableMatching, syllableLength } from './utils/koreanSyllable';
 export { isSyllablePattern, matchesSyllablePattern, validateSyllableSearchInput, patternToComposition, matchesWordQuery, searchAndRankWords } from './utils/koreanSyllable';
-export { PLAN_FEATURES, PLAN_LIMITS, TIER_RANK, getPlanTier, type PlanTier, type DataLevel, type PlanFeatures, type PlanLimits, } from './utils/planFeatures';
+export { PLAN_FEATURES, PLAN_LIMITS, TIER_RANK, getPlanTier, isManagerTier, type PlanTier, type DataLevel, type PlanFeatures, type PlanLimits, } from './utils/planFeatures';
 export { WORD_SUGGESTION_WEEKLY_QUOTA, WORD_SUGGESTION_ACCOUNT_LIMIT, WORD_SUGGESTION_EXISTING_ERROR, isThisWeekPick, } from './utils/wordSuggestionPolicy';
 export { CORE_VERSION } from './version';

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

@@ -39,7 +39,7 @@ export { isSyllablePattern, matchesSyllablePattern, validateSyllableSearchInput,
 /* 요금제 정의 — 회원앱과 말귀어드민이 둘 다 본다. 예전에는 회원앱(src/libs) 안에 있었고
    어드민이 '@app/libs/planFeatures' 로 끌어다 썼는데, 그 한 줄 때문에 어드민이 회원앱
    폴더 없이는 빌드되지 않았다. 값과 타입뿐이라 코어에 두는 게 맞다. */
-export { PLAN_FEATURES, PLAN_LIMITS, TIER_RANK, getPlanTier, } from './utils/planFeatures';
+export { PLAN_FEATURES, PLAN_LIMITS, TIER_RANK, getPlanTier, isManagerTier, } from './utils/planFeatures';
 /* 단어 제안 정책 — 요금제와 똑같은 까닭으로 여기 있다. 회원앱(단어 제안)과
    말귀어드민(단어 제안 관리)이 같은 숫자를 봐야 하는데, 한쪽 화면 폴더에 두면
    다른 쪽이 그 폴더 없이는 빌드되지 않는다. 값과 순수 함수뿐이다. */

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

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

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

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