ko-chrono 0.2.0 → 0.3.1

package/README.md

@@ -14,6 +14,8 @@
   <img alt="'그럼 다음주 화요일 오후 3시에 볼까?'에서 '다음주 화요일 오후 3시'를 찾아 2026-11-03 15:00으로 바꾼다" src="./docs/banner-light.svg" width="760">
 </picture>
 
+**[▶ 브라우저에서 바로 해 보기](https://jwn7.github.io/ko-chrono/)**
+
 [설치](#설치) · [사용법](#사용법) · [지원 표현](#지원-표현) · [해석 규칙](#해석-규칙) · [예제](#예제) · [문장 제보](https://github.com/jwn7/ko-chrono/issues/new?template=sentence.yml)
 
 </div>
@@ -88,6 +90,26 @@ parseEvent('우유 사기');
 // { title: '우유 사기', date: null, hasTime: false }
 ```
 
+### 애매한 해석: `ambiguity`
+
+"3시"가 오후인지 새벽인지처럼 해석이 갈릴 수 있으면, 기본 해석은 그대로 두고 다른 후보를 함께 알려 줍니다.
+사용자에게 되묻거나, 이런 문장만 LLM에 넘길 때 쓰면 됩니다.
+
+```ts
+const r = parse('3시에 보자');
+// r.date      → 오늘 15:00 (오전/오후가 없는 1~6시는 오후로)
+// r.ambiguity → { reason: 'meridiem', alternatives: [내일 03:00] }
+
+if (!r) askLLM(text);                                 // 날짜를 못 찾음
+else if (r.ambiguity?.alternatives.length) confirm(r);  // "오후 3시 맞으세요?"
+```
+
+| `reason` | 언제 | `alternatives` |
+|---|---|---|
+| `meridiem` | 오전/오후 없는 1\~12시 ("3시", "내일 7시") | 반대쪽 12시간 |
+| `next-weekday` | "다음 토요일"이 이번 주 토요일일 수도, 다음 주 토요일일 수도 | 다른 쪽 날짜 |
+| `approximate-time` | "저녁"(19시), "아침"(8시)처럼 관례로 정한 시각 | 없음 |
+
 ### 반복 일정
 
 `recurrence.rrule`은 [RFC 5545 RRULE](https://icalendar.org/iCalendar-RFC-5545/3-8-5-3-recurrence-rule.html)이라 Google·Apple 캘린더, iCal에 그대로 넣을 수 있습니다. `date`는 기준 시각 이후 첫 발생입니다.
@@ -121,6 +143,7 @@ parse('격주 화요일')?.recurrence?.rrule;                 // 'FREQ=WEEKLY;IN
 | `index` | 문장 안에서의 위치 |
 | `hasTime` | 시각까지 말했는지. `false`면 `date`는 그날 `defaultHour`시 |
 | `recurrence` | 반복 일정이면 규칙 (`freq`, `interval`, `byWeekday`, …, `rrule`) |
+| `ambiguity` | 해석이 갈릴 수 있으면 `{ reason, alternatives }` |
 
 ### 옵션
 
@@ -154,6 +177,8 @@ parse('격주 화요일')?.recurrence?.rrule;                 // 'FREQ=WEEKLY;IN
 | 마감 | \~까지 · \~안에 · \~중으로 · 이번 주 안에 · 오전 중으로 · 퇴근 전까지 |
 | 구간 | A부터 B까지 · 3\~5시 · 월\~금 · 오늘부터 3일간 · 3박 4일 · 이번 주 내내 |
 | 공휴일·명절 | 크리스마스 · 빼빼로데이 · 광복절 전날 · 설날 · 설 연휴 · 추석 전날 · 부처님 오신 날 |
+| 음력 | 음력 3월 3일 · 음력 윤5월 1일 · 2028년 음력 9월 9일 |
+| 업무용 한자어 | 금일 · 명일 · 익일 · 작일 · 금주 · 차주 · 전주 수요일 · 익월 초 · 금월 말까지 · 익년 |
 | 반복 | 매일 · 매주 월수금 · 매주 월\~금 · 격주 · 평일마다 · 매달 15일 · 매월 말일 · 매달 마지막 주 금요일 · 매년 3월 1일 · 2시간마다 |
 | 문장 | 띄어쓰기 생략 · 조사(은·는·도) · 어림말(쯤·경·께) · 여러 개 추출 |
 
@@ -195,12 +220,14 @@ parse('격주 화요일')?.recurrence?.rrule;                 // 'FREQ=WEEKLY;IN
 - "오늘부터 3일간" → `end`는 3일째 되는 날 23:59
 
 **명절**
+- "음력 3월 3일"처럼 음력이라고 말한 날짜도 같은 자료로 변환합니다
 - 설날·추석·부처님 오신 날은 [한국천문연구원](https://astro.kasi.re.kr/life/post/calendarData) 자료가 있는 연도(현재 2025\~2028)만. 그 뒤는 추측하지 않고 `null`
 - "설 연휴", "추석 연휴" = 전날부터 다음날까지 3일
 
 **잡지 않는 것**
 - 없는 날짜 (2월 30일, 11월 31일), 날짜와 요일이 안 맞는 경우 ("11월 5일 수요일")
 - 기간만 있는 표현 ("3일간", "3박 4일"), 날짜가 아닌 말 ("3일 연속", "1월생", "내가 낼게")
+- 한자어가 다른 뜻일 때: "금주 결심"(禁酒), "전주 여행"(도시), "차주에게 연락"(車主), "전월세"
 - "내일 30분 후"처럼 날짜와 상대 시간이 섞이면 두 개의 결과로 나눔
 
 </details>
@@ -213,7 +240,7 @@ parse('격주 화요일')?.recurrence?.rrule;                 // 'FREQ=WEEKLY;IN
 |---|---|---|
 | ✅ | [**할 일 빠른 입력**](./examples/quick-add.mjs)<br>`parseEvent`로 "다음주 금요일까지 보고서 제출" → 제목 "보고서 제출" + 마감 11/6 23:59 | `node examples/quick-add.mjs "..."` |
 | 💬 | [**Slack 봇**](./examples/slack-bot)<br>채널 메시지에서 날짜를 찾아 스레드로 알려줌 (UTC 서버 + `timezone`) | `node examples/slack-bot/try.mjs` |
-| 🧪 | [**Playground**](./playground/index.html)<br>브라우저에서 직접 입력해 보기 | `npm run playground` |
+| 🧪 | [**Playground**](https://jwn7.github.io/ko-chrono/)<br>브라우저에서 직접 입력해 보기 (문장을 넣으면 공유 링크가 생김) | [jwn7.github.io/ko-chrono](https://jwn7.github.io/ko-chrono/) · 로컬은 `npm run playground` |
 
 <br>
 
@@ -221,16 +248,18 @@ parse('격주 화요일')?.recurrence?.rrule;                 // 'FREQ=WEEKLY;IN
 
 날짜를 LLM에 물어볼 수도 있지만, 정해진 규칙으로 풀리는 문제라면 이쪽이 빠르고 공짜이고 매번 같은 답을 냅니다.
 
-| | ko-chrono | LLM API |
+메신저 문장 112개로 측정한 결과 ([자세히](./bench/RESULTS.md), Gemini Flash-Lite **무료 티어**, 2026-10-31):
+
+| | ko-chrono | LLM API (Gemini Flash-Lite) |
 |---|---|---|
-| 지연 | 문장당 약 **0.01ms** | 문장당 수백 ms \~ 수 초 |
-| 비용 | **0** | 토큰당 과금 |
+| 지연 | 문장당 **0.017ms** | 문장당 **987ms** (네트워크만 40ms 이상) |
+| 비용 | **0** | 토큰당 과금 (무료 티어는 분당·일일 한도) |
 | 같은 문장 → 같은 답 | **항상** | 보장 안 됨 |
 | 오프라인 · 브라우저 | **됨** | 안 됨 |
+| 시제·문맥 ("깨서 못 잤어") | 모름 | 앎 |
 | 처음 보는 표현 | 못 함 (`null`) | 대체로 함 |
 
-같은 메신저 문장 112개를 양쪽에 넣어 비교하는 벤치마크가 [bench/](./bench)에 있습니다 (Claude, Gemini 지원).
-규칙으로 풀리는 날짜는 ko-chrono로, 그 밖의 자유로운 문장만 LLM으로 보내는 조합을 권합니다.
+유료 티어나 다른 모델이면 LLM 쪽이 더 빠를 수 있지만, 네트워크 왕복만으로도 ko-chrono보다 수천 배 느립니다. 정확도는 비슷한 수준이고 차이의 절반은 "저녁이 몇 시냐" 같은 관례 차이였습니다. 규칙으로 풀리는 날짜는 ko-chrono로, `null`이 나오거나 `ambiguity`가 있는 문장만 LLM으로 보내는 조합을 권합니다.
 
 <br>
 
@@ -239,8 +268,9 @@ parse('격주 화요일')?.recurrence?.rrule;                 // 'FREQ=WEEKLY;IN
 - [x] 반복 일정 (매주 월요일 9시, 격주) → RRULE
 - [x] 제목 분리 (`parseEvent`)
 - [x] 명절·공휴일 (설 연휴, 추석 전날, 크리스마스) — 음력 명절은 한국천문연구원 자료가 있는 2025\~2028년
-- [ ] 일반 음력 날짜 (음력 3월 3일)
-- [ ] chrono-node `ko` 로케일 기여
+- [x] 일반 음력 날짜 (음력 3월 3일) — 한국천문연구원 자료가 있는 2025\~2028년
+- [x] 모호성 정보 (`ambiguity`)
+- [ ] chrono-node `ko` 로케일 기여 — 첫 PR 분량 준비됨 ([contrib/chrono-ko](./contrib/chrono-ko))
 
 ## 기여
 

package/dist/cjs/event.d.ts

@@ -1,4 +1,4 @@
-import type { ParseResult, Recurrence } from './types.js';
+import type { Ambiguity, ParseResult, Recurrence } from './types.js';
 /** parseEvent()의 결과: 할 일·일정 한 줄을 제목과 시점으로 나눈 것 */
 export interface ParsedEvent {
     /** 날짜 부분을 뺀 나머지 ("내일 3시 치과" → "치과"). 없으면 '' */
@@ -10,6 +10,8 @@ export interface ParsedEvent {
     hasTime: boolean;
     /** 반복 일정이면 그 규칙 */
     recurrence?: Recurrence;
+    /** 해석이 갈릴 수 있으면 그 이유와 다른 후보 ("3시" → 15시, 후보 3시) */
+    ambiguity?: Ambiguity;
 }
 /**
  * 문장에서 날짜로 인식된 부분과 거기 붙은 조사를 빼서 제목을 만든다 (규칙 28).

package/dist/cjs/event.js

@@ -27,5 +27,7 @@ function toEvent(text, results) {
         event.end = first.end;
     if (first.recurrence)
         event.recurrence = first.recurrence;
+    if (first.ambiguity)
+        event.ambiguity = first.ambiguity;
     return event;
 }

package/dist/cjs/index.d.ts

@@ -1,6 +1,6 @@
 import type { ParseOptions, ParseResult } from './types.js';
 import { type ParsedEvent } from './event.js';
-export type { Frequency, ParseOptions, ParseResult, Recurrence, WeekStart } from './types.js';
+export type { Ambiguity, Frequency, ParseOptions, ParseResult, Recurrence, WeekStart } from './types.js';
 export type { ParsedEvent } from './event.js';
 /**
  * 문장에서 모든 날짜/시간 표현을 찾는다. 등장 순서대로 반환하며, 없으면 빈 배열.

package/dist/cjs/index.js

@@ -64,6 +64,9 @@ function parseAll(text, options) {
         const out = { ...r, date: (0, timezone_js_1.fromWallClock)(r.date, timezone) };
         if (r.end)
             out.end = (0, timezone_js_1.fromWallClock)(r.end, timezone);
+        if (r.ambiguity) {
+            out.ambiguity = { ...r.ambiguity, alternatives: r.ambiguity.alternatives.map((a) => (0, timezone_js_1.fromWallClock)(a, timezone)) };
+        }
         return out;
     });
 }

package/dist/cjs/parsers/holiday.js

@@ -31,6 +31,8 @@ const MODIFIER = '(?:\\s*(전날|다음\\s*날|이튿날|당일))?';
 const FIXED_RE = new RegExp(`(${Object.keys(FIXED).map((k) => k.replace(/ /g, '\\s*')).join('|')})${MODIFIER}`, 'g');
 // "설날", "구정", "설 연휴", "추석 전날", "한가위", "부처님 오신 날". "설"만은 "설명", "설거지"와 겹쳐서 뒤에 연휴·전날 등이 올 때만
 const LUNAR_RE = /(설날|구정|설(?=\s*(?:연휴|전날|다음\s*날|당일))|추석|한가위|부처님\s*오신\s*날|석가\s*탄신일|석탄일|초파일)(?:\s*(연휴))?(?:\s*(전날|다음\s*날|이튿날|당일))?/g;
+// "음력 3월 3일", "음력 윤5월 1일" (음력이라고 말한 경우만)
+const LUNAR_DATE_RE = /음력\s*(윤\s*)?(\d{1,2})\s*월\s*(\d{1,2})\s*일/g;
 const fixedKey = (name) => Object.keys(FIXED).find((k) => k.replace(/ /g, '') === name.replace(/\s/g, ''));
 const shiftOf = (m) => (m ? SHIFT[m.replace(/\s/g, '')] : 0);
 /** 공휴일·기념일·명절. 음력 명절의 양력 날짜는 resolve가 표에서 찾는다 */
@@ -44,6 +46,12 @@ const holiday = (text) => {
             c.dayOffset = shift;
         out.push({ text: m[0], index: m.index, components: c });
     }
+    for (const m of text.matchAll(LUNAR_DATE_RE)) {
+        const month = +m[2], day = +m[3];
+        if (month < 1 || month > 12 || day < 1 || day > 30)
+            continue;
+        out.push({ text: m[0], index: m.index, components: { lunarDate: { month, day, leap: !!m[1] } } });
+    }
     for (const m of text.matchAll(LUNAR_RE)) {
         const name = m[1].replace(/\s/g, '');
         const lunar = name === '설날' || name === '구정' || name === '설' ? 'seollal'

package/dist/cjs/parsers/relativeDay.js

@@ -3,6 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.relativeDay = void 0;
 const WORDS = {
     그저께: -2,
+    // 업무용 한자어 (규칙 33)
+    금일: 0,
+    명일: 1,
+    익일: 1,
+    작일: -1,
     내일모레: 2,
     낼모레: 2,
     낼: 1,
@@ -13,8 +18,8 @@ const WORDS = {
     모레: 2,
     글피: 3,
 };
-// "내일모레"는 "내일"+"모레"가 아니라 모레. "낼"은 "내가 낼게"(내다)와 겹쳐서 뒤에 시각·약속 표현이 올 때만
-const RE = /(그저께|그제|어제|오늘|내일모레|낼모레|내일|모레|글피|(?<![가-힣])낼(?=\s*(?:오전|오후|아침|점심|저녁|밤|새벽|낮|\d|봐|보자|만나|까지)))/g;
+// "금일", "익일 배송", "작일" (업무용 한자어). "내일모레"는 "내일"+"모레"가 아니라 모레. "낼"은 "내가 낼게"(내다)와 겹쳐서 뒤에 시각·약속 표현이 올 때만
+const RE = /(그저께|그제|어제|오늘|내일모레|낼모레|내일|모레|글피|(?<![가-힣])(?:금일|명일|익일|작일)|(?<![가-힣])낼(?=\s*(?:오전|오후|아침|점심|저녁|밤|새벽|낮|\d|봐|보자|만나|까지)))/g;
 /** 오늘/내일/모레/글피/어제/그저께 */
 const relativeDay = (text) => {
     const out = [];

package/dist/cjs/parsers/relativeMonth.js

@@ -7,6 +7,9 @@ const PART = { 초: 'start', 중순: 'middle', 말: 'end' };
 const RE = /(지난|저번|이번|다다음|다음|담)\s*달\s*(초|중순|말|이맘때)?|(?<![가-힣])월(초|말)/g;
 // "11월 말", "12월 초" (absoluteDate의 MONTH_ONLY와 겹치지만 part가 있는 경우 우선)
 const ABS_PART = /(?<![\d가-힣])(\d{1,2})\s*월\s*(초|중순|말)/g;
+// 업무용 한자어 달 (규칙 33): "익월 초", "금월 말까지", "전월 실적". "전월세"는 제외
+const FORMAL_MONTH = /(?<![가-힣])(금|익|차|전)월(?!세)(?:\s*(초|중순|말))?/g;
+const FORMAL_MONTH_OFFSET = { 금: 0, 익: 1, 차: 1, 전: -1 };
 /** 이번달/다음달 (초/중순/말) */
 const relativeMonth = (text) => {
     const out = [];
@@ -22,6 +25,12 @@ const relativeMonth = (text) => {
             c.monthPart = PART[m[2]];
         out.push({ text: m[0], index: m.index, components: c });
     }
+    for (const m of text.matchAll(FORMAL_MONTH)) {
+        const c = { monthOffset: FORMAL_MONTH_OFFSET[m[1]] };
+        if (m[2])
+            c.monthPart = PART[m[2]];
+        out.push({ text: m[0], index: m.index, components: c });
+    }
     for (const m of text.matchAll(ABS_PART)) {
         out.push({ text: m[0], index: m.index, components: { month: +m[1], monthPart: PART[m[2]] } });
     }

package/dist/cjs/parsers/relativeYear.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.relativeYear = void 0;
 const WORDS = {
-    재작년: -2, 작년: -1, 지난해: -1, 올해: 0, 금년: 0, 내년: 1, 명년: 1, 내후년: 2,
+    재작년: -2, 작년: -1, 지난해: -1, 올해: 0, 금년: 0, 내년: 1, 명년: 1, 익년: 1, 내후년: 2,
 };
 // "올해 말", "내년 초", "작년", "재작년", "내후년", "지난해", "내년 이맘때", "연말", "연초"
-const RE = /(재작년|작년|지난해|올해|금년|내후년|내년|명년)(?:\s*(초|말|이맘때))?|(?<![가-힣])(연말(?!정산)|연초)/g;
+const RE = /(재작년|작년|지난해|올해|금년|내후년|내년|명년|익년)(?:\s*(초|말|이맘때))?|(?<![가-힣])(연말(?!정산)|연초)/g;
 /** 올해/내년/작년 (초/말) */
 const relativeYear = (text) => {
     const out = [];

package/dist/cjs/parsers/time.js

@@ -134,7 +134,7 @@ const time = (text) => {
     for (const m of text.matchAll(HALF_WORD)) {
         if (!take(m.index, m[0].length))
             continue;
-        out.push({ text: m[0], index: m.index, components: { hour: WORD_HOUR[m[1]], minute: 0, meridiem: true } });
+        out.push({ text: m[0], index: m.index, components: { hour: WORD_HOUR[m[1]], minute: 0, meridiem: true, approximate: true } });
     }
     for (const m of text.matchAll(WORD)) {
         if (!take(m.index, m[0].length))
@@ -142,6 +142,9 @@ const time = (text) => {
         const c = { hour: WORD_HOUR[m[1]], minute: 0, meridiem: true };
         if (m[1] === '자정')
             c.midnight = true;
+        // 정오·자정은 정확한 시각, 나머지(아침·저녁·밤·점심·낮·퇴근)는 관례
+        else if (m[1] !== '정오')
+            c.approximate = true;
         out.push({ text: m[0], index: m.index, components: c });
     }
     return out;

package/dist/cjs/parsers/weekday.js

@@ -20,6 +20,13 @@ const NTH = new RegExp(`(?:(\\d{1,2})\\s*월\\s*)?(첫째|첫|둘째|셋째|넷
 const NTH_NUM = { 첫째: 1, 첫: 1, 둘째: 2, 셋째: 3, 넷째: 4, 다섯째: 5, 마지막: -1 };
 // "2주 뒤 월요일", "3주 후 금요일" → N주 뒤의 그 주의 X요일 ("다다음주 월요일"과 같은 계산)
 const WEEKS_LATER = new RegExp(`(\\d{1,2}|한|두|세|네|다섯)\\s*주\\s*(?:뒤|후)\\s*(${DAY})(?:요일|욜)`, 'g');
+// 업무용 한자어 주 (규칙 33): "차주 금요일", "금주 월요일", "전주 수요일". 금주(禁酒)·전주(도시)·차주(車主)와
+// 겹치므로 요일은 "요일/욜"까지 붙어야 하고, 요일 없이 쓸 때는 뒤에 날짜 말(내로·중으로·에·까지…)이 와야 한다.
+// "전주"는 도시 이름과 너무 자주 겹쳐서 요일이 붙을 때만
+const FORMAL_WEEK = { 전전: -2, 전: -1, 금: 0, 차: 1, 익: 1, 차차: 2 };
+const FORMAL_WITH_DAY = new RegExp(`(?<![가-힣])(전전|차차|전|금|차|익)주\\s*(${DAY})(?:요일|욜)`, 'g');
+// "차주 중으로", "금주 내로", "차주에 회의", "익주까지". "금주에"는 "금주에 성공했어"(禁酒)와 겹쳐서 제외
+const FORMAL_WEEK_ONLY = /(?<![가-힣])(?:(전전|차차|차|익)주(?=\s*(?:에(?!게|서)|에는|중으로|중에|내로|내|안에|안으로|까지|초|말|부터))|(금)주(?=\s*(?:중으로|중에|내로|내|안에|안으로|까지|초|말|부터)))/g;
 // "지난 금요일" = 오늘 제외 가장 가까운 과거, "다음 금요일" = 오늘 제외 가장 가까운 미래
 const DIR = new RegExp(`(지난|저번|다음)\\s*(${DAY})(?:요일|욜)`, 'g');
 // "주말에 보자" ("이번 주말"은 위 WEEKEND가 먼저 잡는다)
@@ -35,6 +42,16 @@ const weekday = (text) => {
     const out = [];
     const taken = [];
     const overlaps = (i, len) => taken.some(([s, e]) => i < e && i + len > s);
+    for (const m of text.matchAll(FORMAL_WITH_DAY)) {
+        out.push({ text: m[0], index: m.index, components: { weekOffset: FORMAL_WEEK[m[1]], weekday: WEEKDAY[m[2]] } });
+        taken.push([m.index, m.index + m[0].length]);
+    }
+    for (const m of text.matchAll(FORMAL_WEEK_ONLY)) {
+        if (overlaps(m.index, m[0].length))
+            continue;
+        out.push({ text: m[0], index: m.index, components: { weekOffset: FORMAL_WEEK[m[1] ?? m[2]] } });
+        taken.push([m.index, m.index + m[0].length]);
+    }
     for (const m of text.matchAll(WEEKS_LATER)) {
         const n = (0, number_js_1.parseKoreanNumber)(m[1]);
         if (n == null)

package/dist/cjs/resolve.js

@@ -71,6 +71,7 @@ function merge(list) {
 }
 const DATE_KEYS = [
     'year', 'yearOffset', 'month', 'day', 'dayOffset', 'weekOffset', 'weekday', 'monthOffset', 'monthPart',
+    'lunar', 'lunarDate',
 ];
 /** 날짜 정보 없이 시각만 있는 조각인지 ("5시까지", "17:00") */
 function isTimeOnly(c) {
@@ -137,21 +138,24 @@ function resolve(group, opts) {
     d.setSeconds(0, 0);
     let dateSet = false;
     const hasTime = c.hour !== undefined || c.hourOffset !== undefined || c.minuteOffset !== undefined;
-    // 0. 음력 명절 (규칙 29): 연도를 말했으면 그 해, 아니면 올해 것이 (연휴까지) 지났을 때 내년.
-    //    공식 자료가 없는 연도는 null
+    // 0. 음력 명절·음력 날짜 (규칙 29, 32): 연도를 말했으면 그 음력 해, 아니면 (연휴까지) 지나지 않은 가장 가까운 것.
+    //    음력 12월은 양력으로 다음 해 1월이라 작년 음력부터 본다. 표에 없는 날짜는 null
     const hasYear = c.year !== undefined || c.yearOffset !== undefined;
-    if (c.lunar) {
+    const isLunar = c.lunar !== undefined || c.lunarDate !== undefined;
+    if (isLunar) {
         const said = c.year ?? (c.yearOffset !== undefined ? ref.getFullYear() + c.yearOffset : undefined);
         const tail = (c.dayOffset ?? 0) + (c.durationDays ? c.durationDays - 1 : 0);
-        const years = said !== undefined ? [said] : [ref.getFullYear(), ref.getFullYear() + 1];
+        const y0 = ref.getFullYear();
+        const years = said !== undefined ? [said] : [y0 - 1, y0, y0 + 1, y0 + 2];
+        const solarOf = (y) => c.lunar ? (0, lunarHolidays_js_1.lunarHoliday)(y, c.lunar) : (0, lunarHolidays_js_1.lunarToSolar)(y, c.lunarDate.month, c.lunarDate.day, c.lunarDate.leap);
         let found = null;
         for (const y of years) {
-            const md = lunarHolidays_js_1.LUNAR_HOLIDAYS[y]?.[c.lunar];
-            if (!md)
-                break;
-            const lastMoment = new Date(y, md[0] - 1, md[1] + tail, 23, 59);
+            const s = solarOf(y);
+            if (!s)
+                continue; // 그 해에 없는 날 ("음력 2월 30일", 윤달)
+            const lastMoment = new Date(s.getFullYear(), s.getMonth(), s.getDate() + tail, 23, 59);
             if (said !== undefined || lastMoment >= ref) {
-                found = new Date(y, md[0] - 1, md[1]);
+                found = s;
                 break;
             }
         }
@@ -161,7 +165,7 @@ function resolve(group, opts) {
         dateSet = true;
     }
     // 1. 절대 날짜
-    if (!c.lunar && (hasYear || c.month !== undefined || c.day !== undefined)) {
+    if (!isLunar && (hasYear || c.month !== undefined || c.day !== undefined)) {
         let y = c.year ?? ref.getFullYear() + (c.yearOffset ?? 0);
         // "작년", "내년"처럼 연도만 있으면 1월 1일. "내년 이맘때", "1년 뒤"는 오늘 날짜 유지
         const m0 = c.month !== undefined ? c.month - 1 : hasYear && !c.sameDay ? 0 : ref.getMonth();
@@ -287,10 +291,13 @@ function resolve(group, opts) {
     // 안전장치: 어떤 경로로든 계산이 깨진 날짜는 내보내지 않는다
     if (Number.isNaN(d.getTime()))
         return null;
+    const ambiguity = ambiguityOf(c, d, dateSet, opts);
     const first = group[0];
     const last = group[group.length - 1];
     // text는 parseAll()에서 원문 slice로 채운다. _end는 그때 쓰는 내부 값.
     const result = { date: d, text: '', index: first.index, hasTime };
+    if (ambiguity)
+        result.ambiguity = ambiguity;
     result._end = last.index + last.text.length;
     // "오늘부터 3일간", "3시부터 2시간 동안": 시작일을 포함한 기간의 끝
     if (c.durationDays !== undefined || c.durationMonths !== undefined || c.durationMinutes !== undefined) {
@@ -405,6 +412,31 @@ function resolveRecurrence(group, c, opts) {
     result._end = last.index + last.text.length;
     return result;
 }
+/** 규칙 31: 해석이 갈릴 수 있는 지점과 다른 후보 */
+function ambiguityOf(c, d, dateSet, opts) {
+    const ref = opts.referenceDate;
+    // 오전/오후 없는 1~12시: 반대쪽 12시간이 후보 (날짜가 없으면 규칙 4대로 다음 발생)
+    if (c.hour !== undefined && !c.meridiem && !c.midnight && c.hour >= 1 && c.hour <= 12) {
+        const used = clockHour(c);
+        const altHour = used === 12 ? 0 : used < 12 ? used + 12 : used - 12;
+        const alt = new Date(dateSet ? d : ref);
+        alt.setHours(altHour, c.minute ?? 0, 0, 0);
+        if (!dateSet && alt < ref)
+            alt.setDate(alt.getDate() + 1);
+        return { reason: 'meridiem', alternatives: [alt] };
+    }
+    // "다음 토요일": 규칙 23(오늘 제외 가장 가까운)과 "다음 주 토요일"이 다르면 후보로
+    if (c.weekdayDir === 'next' && c.weekday !== undefined) {
+        const alt = startOfWeek(ref, opts.weekStart);
+        alt.setDate(alt.getDate() + 7 + (opts.weekStart === 'monday' ? (c.weekday + 6) % 7 : c.weekday));
+        alt.setHours(d.getHours(), d.getMinutes(), 0, 0);
+        if (alt.getTime() !== d.getTime())
+            return { reason: 'next-weekday', alternatives: [alt] };
+    }
+    if (c.approximate)
+        return { reason: 'approximate-time', alternatives: [] };
+    return undefined;
+}
 function partDay(y, m0, part) {
     if (part === 'start')
         return 1;

package/dist/cjs/types.d.ts

@@ -34,10 +34,18 @@ export interface Components {
     weekdayDir?: 'past' | 'next';
     /** "1년 뒤", "내년 이맘때": 연/월/주 이동 시 기준일의 날짜를 유지 */
     sameDay?: boolean;
+    /** "저녁", "아침"처럼 관례로 정한 시각 */
+    approximate?: boolean;
     /** "내일 이 시간": 기준 시각의 시:분을 쓴다 */
     sameTime?: boolean;
     /** 음력 명절 (설날·추석·부처님 오신 날). 양력 날짜는 resolve가 util/lunarHolidays 표에서 찾는다 */
     lunar?: 'seollal' | 'chuseok' | 'buddha';
+    /** "음력 3월 3일", "음력 윤5월 1일" */
+    lunarDate?: {
+        month: number;
+        day: number;
+        leap: boolean;
+    };
     /** "매주 월요일", "매달 15일": 반복 규칙 (rrule은 resolve가 만든다) */
     recur?: Omit<Recurrence, 'rrule'>;
     /** 연 단위 이동 (내년=+1). 지정되면 "지난 월일 → 내년" 규칙을 적용하지 않는다 */
@@ -88,6 +96,16 @@ export interface Fragment {
     index: number;
     components: Components;
 }
+/**
+ * 해석이 갈릴 수 있다는 표시 (규칙 31). 기본 해석은 결과의 date(마감이면 end)이고, 다른 후보가 alternatives.
+ * - meridiem: 오전/오후 없는 시각 ("3시" → 15시, 후보 3시)
+ * - next-weekday: "다음 토요일"이 이번 주의 다음 토요일인지 다음 주 토요일인지
+ * - approximate-time: "저녁", "아침"처럼 관례로 정한 시각 (후보 없음)
+ */
+export interface Ambiguity {
+    reason: 'meridiem' | 'next-weekday' | 'approximate-time';
+    alternatives: Date[];
+}
 export interface ParseResult {
     /** 해석된 시각 (구간이면 시작) */
     date: Date;
@@ -101,5 +119,7 @@ export interface ParseResult {
     hasTime: boolean;
     /** 반복 일정이면 그 규칙. date는 기준 시각 이후 첫 발생 */
     recurrence?: Recurrence;
+    /** 해석이 갈릴 수 있으면 그 이유와 다른 후보. 사용자에게 되묻거나 LLM에 넘길지 판단할 때 쓴다 */
+    ambiguity?: Ambiguity;
 }
 export type Parser = (text: string) => Fragment[];

package/dist/cjs/util/lunarHolidays.d.ts

@@ -1,3 +1,11 @@
 export type LunarHoliday = 'seollal' | 'chuseok' | 'buddha';
-/** 연도 → [월, 일] (양력) */
-export declare const LUNAR_HOLIDAYS: Record<number, Record<LunarHoliday, [number, number]>>;
+export declare const LUNAR_YEARS: number[];
+/**
+ * 음력 → 양력. 그 달에 없는 날(29일인 달의 30일)이나 표에 없는 날짜는 null.
+ * 마지막 달처럼 길이를 모르면 29일까지만 받는다.
+ */
+export declare function lunarToSolar(year: number, month: number, day: number, leap?: boolean): Date | null;
+/** 설날(1/1)·부처님 오신 날(4/8)·추석(8/15)의 양력 날짜 */
+export declare function lunarHoliday(year: number, which: LunarHoliday): Date | null;
+/** 각 음력 달의 길이 (검증용). 모르면 null */
+export declare function monthLengths(year: number): (number | null)[];

package/dist/cjs/util/lunarHolidays.js

@@ -1,16 +1,82 @@
 "use strict";
-// 음력 명절의 양력 날짜. 런타임 의존성 없이 음력 변환을 하려면 표가 필요하다.
+// 음력 → 양력 변환표. 런타임 의존성 없이 음력을 다루려면 표가 필요하다.
 //
 // 출처: 한국천문연구원 천문우주지식정보 "월별 양음력 대조" (astro.kasi.re.kr/life/post/calendarData)
-//       2025년은 관공서 공휴일 목록. 2026년 부처님 오신 날·추석은 공휴일 목록으로 교차 확인.
-// KASI는 2~3년 앞까지만 공식 자료를 낸다 (2026-10 기준 2028년까지). 새 연도가 공개되면 한 줄 추가할 것.
-// 표에 없는 연도는 추측하지 않고 null (규칙 10). 한국 설날은 한국 표준시 기준이라 중국 춘절과 하루 다를 수 있다.
+//       2025~2028년 페이지에서 음력 초하루(1일)가 되는 양력 날짜를 옮겼다.
+//       설날·부처님 오신 날·추석 12개가 관공서 공휴일 목록과 일치하는지 tests/lunar.test.ts에서 확인한다.
+// KASI는 2~3년 앞까지만 공식 자료를 낸다 (2026-10 기준 2028년까지).
+// 새 연도가 공개되면 그 해의 초하루 목록을 추가하고, 직전 해 마지막 달의 길이가 확정되는지 확인할 것.
+// 표에 없는 날짜는 추측하지 않고 null (규칙 10). 한국 음력은 한국 표준시 기준이라 중국과 하루 다를 수 있다.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LUNAR_HOLIDAYS = void 0;
-/** 연도 → [월, 일] (양력) */
-exports.LUNAR_HOLIDAYS = {
-    2025: { seollal: [1, 29], buddha: [5, 5], chuseok: [10, 6] },
-    2026: { seollal: [2, 17], buddha: [5, 24], chuseok: [9, 25] },
-    2027: { seollal: [2, 7], buddha: [5, 13], chuseok: [9, 15] },
-    2028: { seollal: [1, 27], buddha: [5, 2], chuseok: [10, 3] },
+exports.LUNAR_YEARS = void 0;
+exports.lunarToSolar = lunarToSolar;
+exports.lunarHoliday = lunarHoliday;
+exports.monthLengths = monthLengths;
+const MONTH_STARTS = {
+    2025: [
+        [1, false, 2025, 1, 29], [2, false, 2025, 2, 28], [3, false, 2025, 3, 29], [4, false, 2025, 4, 28],
+        [5, false, 2025, 5, 27], [6, false, 2025, 6, 25], [6, true, 2025, 7, 25], [7, false, 2025, 8, 23],
+        [8, false, 2025, 9, 22], [9, false, 2025, 10, 21], [10, false, 2025, 11, 20], [11, false, 2025, 12, 20],
+        [12, false, 2026, 1, 19],
+    ],
+    2026: [
+        [1, false, 2026, 2, 17], [2, false, 2026, 3, 19], [3, false, 2026, 4, 17], [4, false, 2026, 5, 17],
+        [5, false, 2026, 6, 15], [6, false, 2026, 7, 14], [7, false, 2026, 8, 13], [8, false, 2026, 9, 11],
+        [9, false, 2026, 10, 11], [10, false, 2026, 11, 9], [11, false, 2026, 12, 9], [12, false, 2027, 1, 8],
+    ],
+    2027: [
+        [1, false, 2027, 2, 7], [2, false, 2027, 3, 8], [3, false, 2027, 4, 7], [4, false, 2027, 5, 6],
+        [5, false, 2027, 6, 5], [6, false, 2027, 7, 4], [7, false, 2027, 8, 2], [8, false, 2027, 9, 1],
+        [9, false, 2027, 9, 30], [10, false, 2027, 10, 29], [11, false, 2027, 11, 28], [12, false, 2027, 12, 28],
+    ],
+    2028: [
+        [1, false, 2028, 1, 27], [2, false, 2028, 2, 25], [3, false, 2028, 3, 26], [4, false, 2028, 4, 25],
+        [5, false, 2028, 5, 24], [5, true, 2028, 6, 23], [6, false, 2028, 7, 22], [7, false, 2028, 8, 20],
+        [8, false, 2028, 9, 19], [9, false, 2028, 10, 18], [10, false, 2028, 11, 16], [11, false, 2028, 12, 16],
+        [12, false, 2029, 1, 15],
+    ],
 };
+exports.LUNAR_YEARS = Object.keys(MONTH_STARTS).map(Number);
+const DAY = 86_400_000;
+const solar = (s) => new Date(s[2], s[3] - 1, s[4]);
+/** 그 음력 달의 다음 달 초하루 (모르면 null) */
+function nextStart(year, index) {
+    const months = MONTH_STARTS[year];
+    if (index + 1 < months.length)
+        return solar(months[index + 1]);
+    const next = MONTH_STARTS[year + 1];
+    return next ? solar(next[0]) : null;
+}
+/**
+ * 음력 → 양력. 그 달에 없는 날(29일인 달의 30일)이나 표에 없는 날짜는 null.
+ * 마지막 달처럼 길이를 모르면 29일까지만 받는다.
+ */
+function lunarToSolar(year, month, day, leap = false) {
+    const months = MONTH_STARTS[year];
+    if (!months || day < 1 || day > 30)
+        return null;
+    const index = months.findIndex(([m, l]) => m === month && l === leap);
+    if (index < 0)
+        return null;
+    const start = solar(months[index]);
+    const next = nextStart(year, index);
+    const length = next ? Math.round((next.getTime() - start.getTime()) / DAY) : 29;
+    if (day > length)
+        return null;
+    return new Date(start.getFullYear(), start.getMonth(), start.getDate() + day - 1);
+}
+/** 설날(1/1)·부처님 오신 날(4/8)·추석(8/15)의 양력 날짜 */
+function lunarHoliday(year, which) {
+    if (which === 'seollal')
+        return lunarToSolar(year, 1, 1);
+    if (which === 'buddha')
+        return lunarToSolar(year, 4, 8);
+    return lunarToSolar(year, 8, 15);
+}
+/** 각 음력 달의 길이 (검증용). 모르면 null */
+function monthLengths(year) {
+    return MONTH_STARTS[year].map((s, i) => {
+        const next = nextStart(year, i);
+        return next ? Math.round((next.getTime() - solar(s).getTime()) / DAY) : null;
+    });
+}

package/dist/event.d.ts

@@ -1,4 +1,4 @@
-import type { ParseResult, Recurrence } from './types.js';
+import type { Ambiguity, ParseResult, Recurrence } from './types.js';
 /** parseEvent()의 결과: 할 일·일정 한 줄을 제목과 시점으로 나눈 것 */
 export interface ParsedEvent {
     /** 날짜 부분을 뺀 나머지 ("내일 3시 치과" → "치과"). 없으면 '' */
@@ -10,6 +10,8 @@ export interface ParsedEvent {
     hasTime: boolean;
     /** 반복 일정이면 그 규칙 */
     recurrence?: Recurrence;
+    /** 해석이 갈릴 수 있으면 그 이유와 다른 후보 ("3시" → 15시, 후보 3시) */
+    ambiguity?: Ambiguity;
 }
 /**
  * 문장에서 날짜로 인식된 부분과 거기 붙은 조사를 빼서 제목을 만든다 (규칙 28).

package/dist/event.js

@@ -24,5 +24,7 @@ export function toEvent(text, results) {
         event.end = first.end;
     if (first.recurrence)
         event.recurrence = first.recurrence;
+    if (first.ambiguity)
+        event.ambiguity = first.ambiguity;
     return event;
 }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { ParseOptions, ParseResult } from './types.js';
 import { type ParsedEvent } from './event.js';
-export type { Frequency, ParseOptions, ParseResult, Recurrence, WeekStart } from './types.js';
+export type { Ambiguity, Frequency, ParseOptions, ParseResult, Recurrence, WeekStart } from './types.js';
 export type { ParsedEvent } from './event.js';
 /**
  * 문장에서 모든 날짜/시간 표현을 찾는다. 등장 순서대로 반환하며, 없으면 빈 배열.

package/dist/index.js

@@ -58,6 +58,9 @@ export function parseAll(text, options) {
         const out = { ...r, date: fromWallClock(r.date, timezone) };
         if (r.end)
             out.end = fromWallClock(r.end, timezone);
+        if (r.ambiguity) {
+            out.ambiguity = { ...r.ambiguity, alternatives: r.ambiguity.alternatives.map((a) => fromWallClock(a, timezone)) };
+        }
         return out;
     });
 }

package/dist/parsers/holiday.js

@@ -28,6 +28,8 @@ const MODIFIER = '(?:\\s*(전날|다음\\s*날|이튿날|당일))?';
 const FIXED_RE = new RegExp(`(${Object.keys(FIXED).map((k) => k.replace(/ /g, '\\s*')).join('|')})${MODIFIER}`, 'g');
 // "설날", "구정", "설 연휴", "추석 전날", "한가위", "부처님 오신 날". "설"만은 "설명", "설거지"와 겹쳐서 뒤에 연휴·전날 등이 올 때만
 const LUNAR_RE = /(설날|구정|설(?=\s*(?:연휴|전날|다음\s*날|당일))|추석|한가위|부처님\s*오신\s*날|석가\s*탄신일|석탄일|초파일)(?:\s*(연휴))?(?:\s*(전날|다음\s*날|이튿날|당일))?/g;
+// "음력 3월 3일", "음력 윤5월 1일" (음력이라고 말한 경우만)
+const LUNAR_DATE_RE = /음력\s*(윤\s*)?(\d{1,2})\s*월\s*(\d{1,2})\s*일/g;
 const fixedKey = (name) => Object.keys(FIXED).find((k) => k.replace(/ /g, '') === name.replace(/\s/g, ''));
 const shiftOf = (m) => (m ? SHIFT[m.replace(/\s/g, '')] : 0);
 /** 공휴일·기념일·명절. 음력 명절의 양력 날짜는 resolve가 표에서 찾는다 */
@@ -41,6 +43,12 @@ export const holiday = (text) => {
             c.dayOffset = shift;
         out.push({ text: m[0], index: m.index, components: c });
     }
+    for (const m of text.matchAll(LUNAR_DATE_RE)) {
+        const month = +m[2], day = +m[3];
+        if (month < 1 || month > 12 || day < 1 || day > 30)
+            continue;
+        out.push({ text: m[0], index: m.index, components: { lunarDate: { month, day, leap: !!m[1] } } });
+    }
     for (const m of text.matchAll(LUNAR_RE)) {
         const name = m[1].replace(/\s/g, '');
         const lunar = name === '설날' || name === '구정' || name === '설' ? 'seollal'

package/dist/parsers/relativeDay.js

@@ -1,5 +1,10 @@
 const WORDS = {
     그저께: -2,
+    // 업무용 한자어 (규칙 33)
+    금일: 0,
+    명일: 1,
+    익일: 1,
+    작일: -1,
     내일모레: 2,
     낼모레: 2,
     낼: 1,
@@ -10,8 +15,8 @@ const WORDS = {
     모레: 2,
     글피: 3,
 };
-// "내일모레"는 "내일"+"모레"가 아니라 모레. "낼"은 "내가 낼게"(내다)와 겹쳐서 뒤에 시각·약속 표현이 올 때만
-const RE = /(그저께|그제|어제|오늘|내일모레|낼모레|내일|모레|글피|(?<![가-힣])낼(?=\s*(?:오전|오후|아침|점심|저녁|밤|새벽|낮|\d|봐|보자|만나|까지)))/g;
+// "금일", "익일 배송", "작일" (업무용 한자어). "내일모레"는 "내일"+"모레"가 아니라 모레. "낼"은 "내가 낼게"(내다)와 겹쳐서 뒤에 시각·약속 표현이 올 때만
+const RE = /(그저께|그제|어제|오늘|내일모레|낼모레|내일|모레|글피|(?<![가-힣])(?:금일|명일|익일|작일)|(?<![가-힣])낼(?=\s*(?:오전|오후|아침|점심|저녁|밤|새벽|낮|\d|봐|보자|만나|까지)))/g;
 /** 오늘/내일/모레/글피/어제/그저께 */
 export const relativeDay = (text) => {
     const out = [];

package/dist/parsers/relativeMonth.js

@@ -4,6 +4,9 @@ const PART = { 초: 'start', 중순: 'middle', 말: 'end' };
 const RE = /(지난|저번|이번|다다음|다음|담)\s*달\s*(초|중순|말|이맘때)?|(?<![가-힣])월(초|말)/g;
 // "11월 말", "12월 초" (absoluteDate의 MONTH_ONLY와 겹치지만 part가 있는 경우 우선)
 const ABS_PART = /(?<![\d가-힣])(\d{1,2})\s*월\s*(초|중순|말)/g;
+// 업무용 한자어 달 (규칙 33): "익월 초", "금월 말까지", "전월 실적". "전월세"는 제외
+const FORMAL_MONTH = /(?<![가-힣])(금|익|차|전)월(?!세)(?:\s*(초|중순|말))?/g;
+const FORMAL_MONTH_OFFSET = { 금: 0, 익: 1, 차: 1, 전: -1 };
 /** 이번달/다음달 (초/중순/말) */
 export const relativeMonth = (text) => {
     const out = [];
@@ -19,6 +22,12 @@ export const relativeMonth = (text) => {
             c.monthPart = PART[m[2]];
         out.push({ text: m[0], index: m.index, components: c });
     }
+    for (const m of text.matchAll(FORMAL_MONTH)) {
+        const c = { monthOffset: FORMAL_MONTH_OFFSET[m[1]] };
+        if (m[2])
+            c.monthPart = PART[m[2]];
+        out.push({ text: m[0], index: m.index, components: c });
+    }
     for (const m of text.matchAll(ABS_PART)) {
         out.push({ text: m[0], index: m.index, components: { month: +m[1], monthPart: PART[m[2]] } });
     }

package/dist/parsers/relativeYear.js

@@ -1,8 +1,8 @@
 const WORDS = {
-    재작년: -2, 작년: -1, 지난해: -1, 올해: 0, 금년: 0, 내년: 1, 명년: 1, 내후년: 2,
+    재작년: -2, 작년: -1, 지난해: -1, 올해: 0, 금년: 0, 내년: 1, 명년: 1, 익년: 1, 내후년: 2,
 };
 // "올해 말", "내년 초", "작년", "재작년", "내후년", "지난해", "내년 이맘때", "연말", "연초"
-const RE = /(재작년|작년|지난해|올해|금년|내후년|내년|명년)(?:\s*(초|말|이맘때))?|(?<![가-힣])(연말(?!정산)|연초)/g;
+const RE = /(재작년|작년|지난해|올해|금년|내후년|내년|명년|익년)(?:\s*(초|말|이맘때))?|(?<![가-힣])(연말(?!정산)|연초)/g;
 /** 올해/내년/작년 (초/말) */
 export const relativeYear = (text) => {
     const out = [];

package/dist/parsers/time.js

@@ -131,7 +131,7 @@ export const time = (text) => {
     for (const m of text.matchAll(HALF_WORD)) {
         if (!take(m.index, m[0].length))
             continue;
-        out.push({ text: m[0], index: m.index, components: { hour: WORD_HOUR[m[1]], minute: 0, meridiem: true } });
+        out.push({ text: m[0], index: m.index, components: { hour: WORD_HOUR[m[1]], minute: 0, meridiem: true, approximate: true } });
     }
     for (const m of text.matchAll(WORD)) {
         if (!take(m.index, m[0].length))
@@ -139,6 +139,9 @@ export const time = (text) => {
         const c = { hour: WORD_HOUR[m[1]], minute: 0, meridiem: true };
         if (m[1] === '자정')
             c.midnight = true;
+        // 정오·자정은 정확한 시각, 나머지(아침·저녁·밤·점심·낮·퇴근)는 관례
+        else if (m[1] !== '정오')
+            c.approximate = true;
         out.push({ text: m[0], index: m.index, components: c });
     }
     return out;

package/dist/parsers/weekday.js

@@ -17,6 +17,13 @@ const NTH = new RegExp(`(?:(\\d{1,2})\\s*월\\s*)?(첫째|첫|둘째|셋째|넷
 const NTH_NUM = { 첫째: 1, 첫: 1, 둘째: 2, 셋째: 3, 넷째: 4, 다섯째: 5, 마지막: -1 };
 // "2주 뒤 월요일", "3주 후 금요일" → N주 뒤의 그 주의 X요일 ("다다음주 월요일"과 같은 계산)
 const WEEKS_LATER = new RegExp(`(\\d{1,2}|한|두|세|네|다섯)\\s*주\\s*(?:뒤|후)\\s*(${DAY})(?:요일|욜)`, 'g');
+// 업무용 한자어 주 (규칙 33): "차주 금요일", "금주 월요일", "전주 수요일". 금주(禁酒)·전주(도시)·차주(車主)와
+// 겹치므로 요일은 "요일/욜"까지 붙어야 하고, 요일 없이 쓸 때는 뒤에 날짜 말(내로·중으로·에·까지…)이 와야 한다.
+// "전주"는 도시 이름과 너무 자주 겹쳐서 요일이 붙을 때만
+const FORMAL_WEEK = { 전전: -2, 전: -1, 금: 0, 차: 1, 익: 1, 차차: 2 };
+const FORMAL_WITH_DAY = new RegExp(`(?<![가-힣])(전전|차차|전|금|차|익)주\\s*(${DAY})(?:요일|욜)`, 'g');
+// "차주 중으로", "금주 내로", "차주에 회의", "익주까지". "금주에"는 "금주에 성공했어"(禁酒)와 겹쳐서 제외
+const FORMAL_WEEK_ONLY = /(?<![가-힣])(?:(전전|차차|차|익)주(?=\s*(?:에(?!게|서)|에는|중으로|중에|내로|내|안에|안으로|까지|초|말|부터))|(금)주(?=\s*(?:중으로|중에|내로|내|안에|안으로|까지|초|말|부터)))/g;
 // "지난 금요일" = 오늘 제외 가장 가까운 과거, "다음 금요일" = 오늘 제외 가장 가까운 미래
 const DIR = new RegExp(`(지난|저번|다음)\\s*(${DAY})(?:요일|욜)`, 'g');
 // "주말에 보자" ("이번 주말"은 위 WEEKEND가 먼저 잡는다)
@@ -32,6 +39,16 @@ export const weekday = (text) => {
     const out = [];
     const taken = [];
     const overlaps = (i, len) => taken.some(([s, e]) => i < e && i + len > s);
+    for (const m of text.matchAll(FORMAL_WITH_DAY)) {
+        out.push({ text: m[0], index: m.index, components: { weekOffset: FORMAL_WEEK[m[1]], weekday: WEEKDAY[m[2]] } });
+        taken.push([m.index, m.index + m[0].length]);
+    }
+    for (const m of text.matchAll(FORMAL_WEEK_ONLY)) {
+        if (overlaps(m.index, m[0].length))
+            continue;
+        out.push({ text: m[0], index: m.index, components: { weekOffset: FORMAL_WEEK[m[1] ?? m[2]] } });
+        taken.push([m.index, m.index + m[0].length]);
+    }
     for (const m of text.matchAll(WEEKS_LATER)) {
         const n = parseKoreanNumber(m[1]);
         if (n == null)

package/dist/resolve.js

@@ -1,5 +1,5 @@
 import { toRRule } from './parsers/recurrence.js';
-import { LUNAR_HOLIDAYS } from './util/lunarHolidays.js';
+import { lunarHoliday, lunarToSolar } from './util/lunarHolidays.js';
 function startOfWeek(d, weekStart) {
     const r = new Date(d);
     r.setHours(0, 0, 0, 0);
@@ -62,6 +62,7 @@ export function merge(list) {
 }
 const DATE_KEYS = [
     'year', 'yearOffset', 'month', 'day', 'dayOffset', 'weekOffset', 'weekday', 'monthOffset', 'monthPart',
+    'lunar', 'lunarDate',
 ];
 /** 날짜 정보 없이 시각만 있는 조각인지 ("5시까지", "17:00") */
 export function isTimeOnly(c) {
@@ -128,21 +129,24 @@ export function resolve(group, opts) {
     d.setSeconds(0, 0);
     let dateSet = false;
     const hasTime = c.hour !== undefined || c.hourOffset !== undefined || c.minuteOffset !== undefined;
-    // 0. 음력 명절 (규칙 29): 연도를 말했으면 그 해, 아니면 올해 것이 (연휴까지) 지났을 때 내년.
-    //    공식 자료가 없는 연도는 null
+    // 0. 음력 명절·음력 날짜 (규칙 29, 32): 연도를 말했으면 그 음력 해, 아니면 (연휴까지) 지나지 않은 가장 가까운 것.
+    //    음력 12월은 양력으로 다음 해 1월이라 작년 음력부터 본다. 표에 없는 날짜는 null
     const hasYear = c.year !== undefined || c.yearOffset !== undefined;
-    if (c.lunar) {
+    const isLunar = c.lunar !== undefined || c.lunarDate !== undefined;
+    if (isLunar) {
         const said = c.year ?? (c.yearOffset !== undefined ? ref.getFullYear() + c.yearOffset : undefined);
         const tail = (c.dayOffset ?? 0) + (c.durationDays ? c.durationDays - 1 : 0);
-        const years = said !== undefined ? [said] : [ref.getFullYear(), ref.getFullYear() + 1];
+        const y0 = ref.getFullYear();
+        const years = said !== undefined ? [said] : [y0 - 1, y0, y0 + 1, y0 + 2];
+        const solarOf = (y) => c.lunar ? lunarHoliday(y, c.lunar) : lunarToSolar(y, c.lunarDate.month, c.lunarDate.day, c.lunarDate.leap);
         let found = null;
         for (const y of years) {
-            const md = LUNAR_HOLIDAYS[y]?.[c.lunar];
-            if (!md)
-                break;
-            const lastMoment = new Date(y, md[0] - 1, md[1] + tail, 23, 59);
+            const s = solarOf(y);
+            if (!s)
+                continue; // 그 해에 없는 날 ("음력 2월 30일", 윤달)
+            const lastMoment = new Date(s.getFullYear(), s.getMonth(), s.getDate() + tail, 23, 59);
             if (said !== undefined || lastMoment >= ref) {
-                found = new Date(y, md[0] - 1, md[1]);
+                found = s;
                 break;
             }
         }
@@ -152,7 +156,7 @@ export function resolve(group, opts) {
         dateSet = true;
     }
     // 1. 절대 날짜
-    if (!c.lunar && (hasYear || c.month !== undefined || c.day !== undefined)) {
+    if (!isLunar && (hasYear || c.month !== undefined || c.day !== undefined)) {
         let y = c.year ?? ref.getFullYear() + (c.yearOffset ?? 0);
         // "작년", "내년"처럼 연도만 있으면 1월 1일. "내년 이맘때", "1년 뒤"는 오늘 날짜 유지
         const m0 = c.month !== undefined ? c.month - 1 : hasYear && !c.sameDay ? 0 : ref.getMonth();
@@ -278,10 +282,13 @@ export function resolve(group, opts) {
     // 안전장치: 어떤 경로로든 계산이 깨진 날짜는 내보내지 않는다
     if (Number.isNaN(d.getTime()))
         return null;
+    const ambiguity = ambiguityOf(c, d, dateSet, opts);
     const first = group[0];
     const last = group[group.length - 1];
     // text는 parseAll()에서 원문 slice로 채운다. _end는 그때 쓰는 내부 값.
     const result = { date: d, text: '', index: first.index, hasTime };
+    if (ambiguity)
+        result.ambiguity = ambiguity;
     result._end = last.index + last.text.length;
     // "오늘부터 3일간", "3시부터 2시간 동안": 시작일을 포함한 기간의 끝
     if (c.durationDays !== undefined || c.durationMonths !== undefined || c.durationMinutes !== undefined) {
@@ -396,6 +403,31 @@ function resolveRecurrence(group, c, opts) {
     result._end = last.index + last.text.length;
     return result;
 }
+/** 규칙 31: 해석이 갈릴 수 있는 지점과 다른 후보 */
+function ambiguityOf(c, d, dateSet, opts) {
+    const ref = opts.referenceDate;
+    // 오전/오후 없는 1~12시: 반대쪽 12시간이 후보 (날짜가 없으면 규칙 4대로 다음 발생)
+    if (c.hour !== undefined && !c.meridiem && !c.midnight && c.hour >= 1 && c.hour <= 12) {
+        const used = clockHour(c);
+        const altHour = used === 12 ? 0 : used < 12 ? used + 12 : used - 12;
+        const alt = new Date(dateSet ? d : ref);
+        alt.setHours(altHour, c.minute ?? 0, 0, 0);
+        if (!dateSet && alt < ref)
+            alt.setDate(alt.getDate() + 1);
+        return { reason: 'meridiem', alternatives: [alt] };
+    }
+    // "다음 토요일": 규칙 23(오늘 제외 가장 가까운)과 "다음 주 토요일"이 다르면 후보로
+    if (c.weekdayDir === 'next' && c.weekday !== undefined) {
+        const alt = startOfWeek(ref, opts.weekStart);
+        alt.setDate(alt.getDate() + 7 + (opts.weekStart === 'monday' ? (c.weekday + 6) % 7 : c.weekday));
+        alt.setHours(d.getHours(), d.getMinutes(), 0, 0);
+        if (alt.getTime() !== d.getTime())
+            return { reason: 'next-weekday', alternatives: [alt] };
+    }
+    if (c.approximate)
+        return { reason: 'approximate-time', alternatives: [] };
+    return undefined;
+}
 function partDay(y, m0, part) {
     if (part === 'start')
         return 1;

package/dist/types.d.ts

@@ -34,10 +34,18 @@ export interface Components {
     weekdayDir?: 'past' | 'next';
     /** "1년 뒤", "내년 이맘때": 연/월/주 이동 시 기준일의 날짜를 유지 */
     sameDay?: boolean;
+    /** "저녁", "아침"처럼 관례로 정한 시각 */
+    approximate?: boolean;
     /** "내일 이 시간": 기준 시각의 시:분을 쓴다 */
     sameTime?: boolean;
     /** 음력 명절 (설날·추석·부처님 오신 날). 양력 날짜는 resolve가 util/lunarHolidays 표에서 찾는다 */
     lunar?: 'seollal' | 'chuseok' | 'buddha';
+    /** "음력 3월 3일", "음력 윤5월 1일" */
+    lunarDate?: {
+        month: number;
+        day: number;
+        leap: boolean;
+    };
     /** "매주 월요일", "매달 15일": 반복 규칙 (rrule은 resolve가 만든다) */
     recur?: Omit<Recurrence, 'rrule'>;
     /** 연 단위 이동 (내년=+1). 지정되면 "지난 월일 → 내년" 규칙을 적용하지 않는다 */
@@ -88,6 +96,16 @@ export interface Fragment {
     index: number;
     components: Components;
 }
+/**
+ * 해석이 갈릴 수 있다는 표시 (규칙 31). 기본 해석은 결과의 date(마감이면 end)이고, 다른 후보가 alternatives.
+ * - meridiem: 오전/오후 없는 시각 ("3시" → 15시, 후보 3시)
+ * - next-weekday: "다음 토요일"이 이번 주의 다음 토요일인지 다음 주 토요일인지
+ * - approximate-time: "저녁", "아침"처럼 관례로 정한 시각 (후보 없음)
+ */
+export interface Ambiguity {
+    reason: 'meridiem' | 'next-weekday' | 'approximate-time';
+    alternatives: Date[];
+}
 export interface ParseResult {
     /** 해석된 시각 (구간이면 시작) */
     date: Date;
@@ -101,5 +119,7 @@ export interface ParseResult {
     hasTime: boolean;
     /** 반복 일정이면 그 규칙. date는 기준 시각 이후 첫 발생 */
     recurrence?: Recurrence;
+    /** 해석이 갈릴 수 있으면 그 이유와 다른 후보. 사용자에게 되묻거나 LLM에 넘길지 판단할 때 쓴다 */
+    ambiguity?: Ambiguity;
 }
 export type Parser = (text: string) => Fragment[];

package/dist/util/lunarHolidays.d.ts

@@ -1,3 +1,11 @@
 export type LunarHoliday = 'seollal' | 'chuseok' | 'buddha';
-/** 연도 → [월, 일] (양력) */
-export declare const LUNAR_HOLIDAYS: Record<number, Record<LunarHoliday, [number, number]>>;
+export declare const LUNAR_YEARS: number[];
+/**
+ * 음력 → 양력. 그 달에 없는 날(29일인 달의 30일)이나 표에 없는 날짜는 null.
+ * 마지막 달처럼 길이를 모르면 29일까지만 받는다.
+ */
+export declare function lunarToSolar(year: number, month: number, day: number, leap?: boolean): Date | null;
+/** 설날(1/1)·부처님 오신 날(4/8)·추석(8/15)의 양력 날짜 */
+export declare function lunarHoliday(year: number, which: LunarHoliday): Date | null;
+/** 각 음력 달의 길이 (검증용). 모르면 null */
+export declare function monthLengths(year: number): (number | null)[];

package/dist/util/lunarHolidays.js

@@ -1,13 +1,76 @@
-// 음력 명절의 양력 날짜. 런타임 의존성 없이 음력 변환을 하려면 표가 필요하다.
+// 음력 → 양력 변환표. 런타임 의존성 없이 음력을 다루려면 표가 필요하다.
 //
 // 출처: 한국천문연구원 천문우주지식정보 "월별 양음력 대조" (astro.kasi.re.kr/life/post/calendarData)
-//       2025년은 관공서 공휴일 목록. 2026년 부처님 오신 날·추석은 공휴일 목록으로 교차 확인.
-// KASI는 2~3년 앞까지만 공식 자료를 낸다 (2026-10 기준 2028년까지). 새 연도가 공개되면 한 줄 추가할 것.
-// 표에 없는 연도는 추측하지 않고 null (규칙 10). 한국 설날은 한국 표준시 기준이라 중국 춘절과 하루 다를 수 있다.
-/** 연도 → [월, 일] (양력) */
-export const LUNAR_HOLIDAYS = {
-    2025: { seollal: [1, 29], buddha: [5, 5], chuseok: [10, 6] },
-    2026: { seollal: [2, 17], buddha: [5, 24], chuseok: [9, 25] },
-    2027: { seollal: [2, 7], buddha: [5, 13], chuseok: [9, 15] },
-    2028: { seollal: [1, 27], buddha: [5, 2], chuseok: [10, 3] },
+//       2025~2028년 페이지에서 음력 초하루(1일)가 되는 양력 날짜를 옮겼다.
+//       설날·부처님 오신 날·추석 12개가 관공서 공휴일 목록과 일치하는지 tests/lunar.test.ts에서 확인한다.
+// KASI는 2~3년 앞까지만 공식 자료를 낸다 (2026-10 기준 2028년까지).
+// 새 연도가 공개되면 그 해의 초하루 목록을 추가하고, 직전 해 마지막 달의 길이가 확정되는지 확인할 것.
+// 표에 없는 날짜는 추측하지 않고 null (규칙 10). 한국 음력은 한국 표준시 기준이라 중국과 하루 다를 수 있다.
+const MONTH_STARTS = {
+    2025: [
+        [1, false, 2025, 1, 29], [2, false, 2025, 2, 28], [3, false, 2025, 3, 29], [4, false, 2025, 4, 28],
+        [5, false, 2025, 5, 27], [6, false, 2025, 6, 25], [6, true, 2025, 7, 25], [7, false, 2025, 8, 23],
+        [8, false, 2025, 9, 22], [9, false, 2025, 10, 21], [10, false, 2025, 11, 20], [11, false, 2025, 12, 20],
+        [12, false, 2026, 1, 19],
+    ],
+    2026: [
+        [1, false, 2026, 2, 17], [2, false, 2026, 3, 19], [3, false, 2026, 4, 17], [4, false, 2026, 5, 17],
+        [5, false, 2026, 6, 15], [6, false, 2026, 7, 14], [7, false, 2026, 8, 13], [8, false, 2026, 9, 11],
+        [9, false, 2026, 10, 11], [10, false, 2026, 11, 9], [11, false, 2026, 12, 9], [12, false, 2027, 1, 8],
+    ],
+    2027: [
+        [1, false, 2027, 2, 7], [2, false, 2027, 3, 8], [3, false, 2027, 4, 7], [4, false, 2027, 5, 6],
+        [5, false, 2027, 6, 5], [6, false, 2027, 7, 4], [7, false, 2027, 8, 2], [8, false, 2027, 9, 1],
+        [9, false, 2027, 9, 30], [10, false, 2027, 10, 29], [11, false, 2027, 11, 28], [12, false, 2027, 12, 28],
+    ],
+    2028: [
+        [1, false, 2028, 1, 27], [2, false, 2028, 2, 25], [3, false, 2028, 3, 26], [4, false, 2028, 4, 25],
+        [5, false, 2028, 5, 24], [5, true, 2028, 6, 23], [6, false, 2028, 7, 22], [7, false, 2028, 8, 20],
+        [8, false, 2028, 9, 19], [9, false, 2028, 10, 18], [10, false, 2028, 11, 16], [11, false, 2028, 12, 16],
+        [12, false, 2029, 1, 15],
+    ],
 };
+export const LUNAR_YEARS = Object.keys(MONTH_STARTS).map(Number);
+const DAY = 86_400_000;
+const solar = (s) => new Date(s[2], s[3] - 1, s[4]);
+/** 그 음력 달의 다음 달 초하루 (모르면 null) */
+function nextStart(year, index) {
+    const months = MONTH_STARTS[year];
+    if (index + 1 < months.length)
+        return solar(months[index + 1]);
+    const next = MONTH_STARTS[year + 1];
+    return next ? solar(next[0]) : null;
+}
+/**
+ * 음력 → 양력. 그 달에 없는 날(29일인 달의 30일)이나 표에 없는 날짜는 null.
+ * 마지막 달처럼 길이를 모르면 29일까지만 받는다.
+ */
+export function lunarToSolar(year, month, day, leap = false) {
+    const months = MONTH_STARTS[year];
+    if (!months || day < 1 || day > 30)
+        return null;
+    const index = months.findIndex(([m, l]) => m === month && l === leap);
+    if (index < 0)
+        return null;
+    const start = solar(months[index]);
+    const next = nextStart(year, index);
+    const length = next ? Math.round((next.getTime() - start.getTime()) / DAY) : 29;
+    if (day > length)
+        return null;
+    return new Date(start.getFullYear(), start.getMonth(), start.getDate() + day - 1);
+}
+/** 설날(1/1)·부처님 오신 날(4/8)·추석(8/15)의 양력 날짜 */
+export function lunarHoliday(year, which) {
+    if (which === 'seollal')
+        return lunarToSolar(year, 1, 1);
+    if (which === 'buddha')
+        return lunarToSolar(year, 4, 8);
+    return lunarToSolar(year, 8, 15);
+}
+/** 각 음력 달의 길이 (검증용). 모르면 null */
+export function monthLengths(year) {
+    return MONTH_STARTS[year].map((s, i) => {
+        const next = nextStart(year, i);
+        return next ? Math.round((next.getTime() - solar(s).getTime()) / DAY) : null;
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ko-chrono",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "한국어 자연어 날짜/시간 파서 — '다음주 화요일 오후 3시' → Date",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -22,6 +22,7 @@
   "files": ["dist", "README.md", "LICENSE"],
   "scripts": {
     "build": "tsc -p tsconfig.build.json && tsc -p tsconfig.cjs.json && node scripts/mark-cjs.mjs",
+    "prepublishOnly": "npm run build && npm test",
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",