@whiteslove/parsing-lexicon 0.8.4 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whiteslove/parsing-lexicon",
-  "version": "0.8.4",
+  "version": "0.9.1",
   "description": "Shared deterministic multilingual parsing lexicon for WhitesLove housing and hiring services",
   "repository": {
     "type": "git",
@@ -197,6 +197,10 @@
       "types": "./src/semantic-spans.d.ts",
       "import": "./src/semantic-spans.js"
     },
+    "./address-grammar": {
+      "types": "./src/address-grammar.d.ts",
+      "import": "./src/address-grammar.js"
+    },
     "./hiring-professions": "./src/hiring-professions.js",
     "./hiring-profession-display": {
       "types": "./src/hiring-profession-display.d.ts",

package/src/address-grammar.d.ts

@@ -0,0 +1,13 @@
+export type AddressGrammarLanguage = 'ru' | 'uk' | 'ro' | 'en' | 'kk' | 'ky' | 'uzLatn' | 'uzCyrl';
+export type AddressGrammarMarker = Readonly<{ pattern: string; lang: AddressGrammarLanguage }>;
+
+export const STREET_PREFIX_MARKERS: readonly AddressGrammarMarker[];
+export const STREET_POSTFIX_MARKERS: readonly AddressGrammarMarker[];
+export const STREET_TYPE_MARKERS: readonly AddressGrammarMarker[];
+export const HOUSE_MARKERS: readonly AddressGrammarMarker[];
+export const BUILDING_MARKERS: readonly AddressGrammarMarker[];
+
+export const COUNTRY_ADDRESS_LANGUAGES: Readonly<Record<string, readonly AddressGrammarLanguage[]>>;
+
+export function combinedMarkerPattern(markers: readonly AddressGrammarMarker[]): string;
+export function matchesCountryAddressLanguage(text: unknown, country: unknown, markers: readonly AddressGrammarMarker[]): boolean;

package/src/address-grammar.js

@@ -0,0 +1,139 @@
+/**
+ * Country/language-scoped address grammar data, extracted from
+ * housing-address.js's combined marker regexes. This is data, not logic:
+ * housing-address.js still runs one shared parser engine and still builds
+ * the exact same combined patterns from these fragments (verified
+ * byte-identical to the pre-extraction hardcoded regex source in
+ * address-grammar.test.js) — nothing about matching behavior changes.
+ *
+ * The value of splitting it out is making "which markers belong to which
+ * language/country" an explicit, inspectable data structure instead of
+ * only implicit in one long alternation, so a caller that already knows
+ * the listing's country can use STREET_GRAMMAR_LANGUAGES_BY_COUNTRY as
+ * scoring evidence (e.g. "this address's markers are consistent with the
+ * supplied country") — a prior, per the plan, never a rigid requirement,
+ * since messy marketplace text routinely mixes languages regardless of
+ * country.
+ */
+
+// Each marker fragment is tagged by the language it belongs to (not the
+// country) because that's what's actually true of the text — "ул./улица"
+// is a Russian-language marker that shows up in UZ, KZ, KG and UA listings
+// alike, not a marker exclusive to one country.
+export const STREET_PREFIX_MARKERS = Object.freeze([
+  { pattern: 'ул(?:ица)?', lang: 'ru' },
+  { pattern: 'вул(?:иця)?', lang: 'uk' },
+  { pattern: 'пр', lang: 'ru' },
+  { pattern: 'просп(?:ект)?', lang: 'ru' },
+  { pattern: 'пр-т', lang: 'ru' },
+  { pattern: 'переул(?:ок)?', lang: 'ru' },
+  { pattern: 'пров(?:улок)?', lang: 'uk' },
+  { pattern: 'проезд', lang: 'ru' },
+  { pattern: 'наб(?:ережная)?', lang: 'ru' },
+  { pattern: 'шоссе', lang: 'ru' },
+  { pattern: "str(?:ada)?", lang: 'ro' },
+  { pattern: 'street', lang: 'en' },
+  { pattern: 'st', lang: 'en' },
+  { pattern: 'avenue', lang: 'en' },
+  { pattern: 'ave', lang: 'en' },
+  { pattern: 'road', lang: 'en' },
+  { pattern: 'rd', lang: 'en' },
+  { pattern: 'көше', lang: 'kk' },
+]);
+
+export const STREET_POSTFIX_MARKERS = Object.freeze([
+  { pattern: 'ko[\'’ʼ\\u02bc]?cha(?:si)?', lang: 'uzLatn' },
+  { pattern: 'кўча(?:си)?', lang: 'uzCyrl' },
+  { pattern: 'коча(?:си)?', lang: 'uzCyrl' },
+  { pattern: 'kocha(?:si)?', lang: 'uzLatn' },
+  { pattern: 'көше(?:сі)?', lang: 'kk' },
+  { pattern: 'көшесі', lang: 'kk' },
+  { pattern: 'көчө(?:сү)?', lang: 'ky' },
+]);
+
+export const STREET_TYPE_MARKERS = Object.freeze([
+  { pattern: 'вулиця', lang: 'uk' },
+  { pattern: 'улица', lang: 'ru' },
+  { pattern: 'провулок', lang: 'uk' },
+  { pattern: 'переулок', lang: 'ru' },
+  { pattern: 'проспект', lang: 'ru' },
+  { pattern: 'бульвар', lang: 'ru' },
+  { pattern: 'набережна', lang: 'uk' },
+  { pattern: 'набережная', lang: 'ru' },
+  { pattern: 'шосе', lang: 'uk' },
+  { pattern: 'шоссе', lang: 'ru' },
+  { pattern: 'площа', lang: 'uk' },
+  { pattern: 'площадь', lang: 'ru' },
+  { pattern: 'узвіз', lang: 'uk' },
+  { pattern: 'спуск', lang: 'ru' },
+  { pattern: 'алея', lang: 'uk' },
+  { pattern: 'аллея', lang: 'ru' },
+  { pattern: 'дорога', lang: 'ru' },
+  { pattern: 'тупик', lang: 'ru' },
+  { pattern: 'көше(?:сі)?', lang: 'kk' },
+  { pattern: 'көшесі', lang: 'kk' },
+  { pattern: 'көчө(?:сү)?', lang: 'ky' },
+]);
+
+export const HOUSE_MARKERS = Object.freeze([
+  { pattern: 'дом', lang: 'ru' },
+  { pattern: 'д\\.', lang: 'ru' },
+  { pattern: 'будинок', lang: 'uk' },
+  { pattern: 'буд\\.', lang: 'uk' },
+  { pattern: 'house', lang: 'en' },
+  { pattern: 'h\\.', lang: 'en' },
+  { pattern: 'uy', lang: 'uzLatn' },
+  { pattern: 'уй', lang: 'uzCyrl' },
+  { pattern: 'үй', lang: 'kk' },
+  { pattern: 'nr\\.?', lang: 'ro' },
+  { pattern: 'no\\.?', lang: 'en' },
+  { pattern: '№', lang: 'ru' },
+]);
+
+export const BUILDING_MARKERS = Object.freeze([
+  { pattern: 'корп(?:ус)?\\.?', lang: 'ru' },
+  { pattern: 'к\\.', lang: 'ru' },
+  { pattern: 'строен(?:ие)?', lang: 'ru' },
+  { pattern: 'стр\\.', lang: 'ru' },
+  { pattern: 'будова', lang: 'uk' },
+  { pattern: 'секц(?:ия|ія)?', lang: 'ru' },
+  { pattern: 'bloc', lang: 'ro' },
+  { pattern: 'corp', lang: 'ro' },
+  { pattern: 'building', lang: 'en' },
+  { pattern: 'bldg\\.?', lang: 'en' },
+  { pattern: 'korpus', lang: 'uzLatn' },
+  { pattern: 'bino', lang: 'uzLatn' },
+  { pattern: 'bina', lang: 'uzLatn' },
+  { pattern: 'бино', lang: 'uzCyrl' },
+]);
+
+// Which languages a given priority country's listings commonly mix, in the
+// order they're worth checking first. Deliberately not exhaustive or
+// exclusive — messy marketplace text can and does use any language
+// regardless of country, so this is scoring-prior data, not a filter.
+export const COUNTRY_ADDRESS_LANGUAGES = Object.freeze({
+  UZ: Object.freeze(['uzLatn', 'uzCyrl', 'ru']),
+  KZ: Object.freeze(['kk', 'ru']),
+  KG: Object.freeze(['ky', 'ru']),
+  UA: Object.freeze(['uk', 'ru']),
+  RO: Object.freeze(['ro']),
+});
+
+function joinMarkerGroup(markers) {
+  return markers.map((marker) => marker.pattern).join('|');
+}
+
+/** Rebuild the exact combined alternation source housing-address.js uses internally, from the tagged marker data above. */
+export function combinedMarkerPattern(markers) {
+  return joinMarkerGroup(markers);
+}
+
+/** True when `text` contains at least one marker tagged for one of `country`'s priority languages. */
+export function matchesCountryAddressLanguage(text, country, markers) {
+  const languages = COUNTRY_ADDRESS_LANGUAGES[String(country || '').toUpperCase()];
+  if (!languages?.length) return false;
+  const relevant = markers.filter((marker) => languages.includes(marker.lang));
+  if (!relevant.length) return false;
+  const pattern = new RegExp(`(?:${joinMarkerGroup(relevant)})`, 'iu');
+  return pattern.test(String(text || ''));
+}

package/src/housing-address.js

@@ -5,14 +5,28 @@ import {
   matchTashkentNumberedArea,
 } from './tashkent-housing-geography.js';
 import { detectNonAddressSpans } from './semantic-spans.js';
+import {
+  BUILDING_MARKERS,
+  HOUSE_MARKERS,
+  STREET_POSTFIX_MARKERS,
+  STREET_PREFIX_MARKERS,
+  STREET_TYPE_MARKERS,
+  combinedMarkerPattern,
+} from './address-grammar.js';
 
 const PHONE_RUN_RE = /\+?\d[\d\s().-]{7,}\d/gu;
 const ADDRESS_LABEL_RE = /(?:адрес|адреса|адресація|адресация|manzil|address|adresă|adresa)\s*[:=\-–—]\s*/iu;
-const PREFIX_STREET_MARKER = String.raw`(?:(?:ул(?:ица)?|вул(?:иця)?|пр|просп(?:ект)?|пр-т|переул(?:ок)?|пров(?:улок)?|проезд|наб(?:ережная)?|шоссе|str(?:ada)?|street|st|avenue|ave|road|rd|көше)\.?)`;
-const POSTFIX_STREET_MARKER = String.raw`(?:ko['’ʼ\u02bc]?cha(?:si)?|кўча(?:си)?|коча(?:си)?|kocha(?:si)?|көше(?:сі)?|көшесі|көчө(?:сү)?)`;
-const POSTFIX_STREET_TYPE = String.raw`(?:вулиця|улица|провулок|переулок|проспект|бульвар|набережна|набережная|шосе|шоссе|площа|площадь|узвіз|спуск|алея|аллея|дорога|тупик|көше(?:сі)?|көшесі|көчө(?:сү)?)`;
-const HOUSE_MARKER = String.raw`(?:дом|д\.|будинок|буд\.|house|h\.|uy|уй|үй|nr\.?|no\.?|№)`;
-const BUILDING_MARKER = String.raw`(?:корп(?:ус)?\.?|к\.|строен(?:ие)?|стр\.|будова|секц(?:ия|ія)?|bloc|corp|building|bldg\.?|korpus|bino|bina|бино)`;
+// These marker alternations are built from address-grammar.js's tagged,
+// per-language fragment data (one shared parser engine, country/language
+// grammar as data — see that file) rather than hardcoded here. The
+// combined pattern strings are verified byte-identical to the original
+// hardcoded regexes in address-grammar.test.js, so this is a pure data
+// extraction with no behavior change.
+const PREFIX_STREET_MARKER = String.raw`(?:(?:${combinedMarkerPattern(STREET_PREFIX_MARKERS)})\.?)`;
+const POSTFIX_STREET_MARKER = `(?:${combinedMarkerPattern(STREET_POSTFIX_MARKERS)})`;
+const POSTFIX_STREET_TYPE = `(?:${combinedMarkerPattern(STREET_TYPE_MARKERS)})`;
+const HOUSE_MARKER = `(?:${combinedMarkerPattern(HOUSE_MARKERS)})`;
+const BUILDING_MARKER = `(?:${combinedMarkerPattern(BUILDING_MARKERS)})`;
 const NUMBER_TOKEN = String.raw`\d{1,5}(?:[-\/]?[\p{L}]\d{0,4})?(?:[\/-]\d{1,4}(?:[-\/]?[\p{L}]\d{0,4})?){0,2}`;
 const STREET_WORD = String.raw`[\p{L}'’.-]{2,48}`;
 // Common post-Soviet street names lead with a bare numeral ("8 Марта",

package/src/housing-money.js

@@ -10,6 +10,7 @@ import {
 import { maskPhoneLikeSpans } from './contact.js';
 import { DEPOSIT_TERMS, SELLER_TERMS } from './housing.js';
 import { COUNTRIES, canonicalCountryCode, countryByCode } from './countries.js';
+import { extractTemporalCandidates } from './temporal.js';
 import {
   classifyHousingSingleMSpans,
   HOUSING_NUMERIC_SPAN_TYPES,
@@ -94,6 +95,21 @@ function parsedMoneyAmount(numberValue, scaleValue) {
 
 const APPROXIMATE_RE = /около|примерно|~|≈/iu;
 
+// A number already claimed by a duration/date/schedule reading ("на 1200
+// дней", "с 2027 года") is not a plausible bare price — it is at least as
+// likely to be that temporal value's own count/year as a price digit that
+// happens to sit near it. This is only used as a last-resort exclusion in
+// the bare-amount fallback below, once every explicit currency/scale/
+// keyword path has already failed to find a price. Only reasonably
+// confident temporal candidates disqualify a span, so an ambiguous bare
+// number elsewhere in the text is unaffected. Calls temporal.js directly
+// rather than semantic-spans.js: that module itself depends on this file's
+// extractHousingMoneyCandidates(), so importing it here would cycle back.
+function overlapsConfidentTemporalSpan(text, start, end) {
+  return extractTemporalCandidates(text).some((item) => (Number(item.confidence) || 0) >= 0.5
+    && start < item.end && item.start < end);
+}
+
 function perSquareMeterMatches(text, fallbackCurrency = '') {
   const matches = [];
   const seen = new Set();
@@ -561,6 +577,10 @@ export function parseHousingPrice(value, context = '') {
         const hasPriceEvidence = PRICE_KEYWORD_RE.test(window) || Boolean(moneyCurrencyFromText(window, ''));
         if (!hasPriceEvidence) continue;
       }
+      // A number already read as a duration/date/schedule value ("\u043D\u0430 1200
+      // \u0434\u043D\u0435\u0439") is not a plausible bare price either \u2014 e.g. "\u0441\u0434\u0430\u044E \u043D\u0430 1200
+      // \u0434\u043D\u0435\u0439" must not report 1200 as the rent.
+      if (overlapsConfidentTemporalSpan(priceText, start, start + raw.length)) continue;
       if (best == null || amount > best) best = amount;
     }
     price = best;

package/src/temporal-calendar-date.js

@@ -0,0 +1,72 @@
+import { HIRING_MONTHS } from './hiring-temporal.js';
+import {
+  candidate,
+  dateEntityType,
+  dateValue,
+  inferYear,
+  inferredDateEvidence,
+  referenceDate,
+  referenceEntry,
+  relationNear,
+  temporalContextType,
+  validDate,
+} from './temporal-shared.js';
+
+/**
+ * CalendarDateParser: absolute calendar dates — numeric ("12.01.2027",
+ * "2027-01-12"), month-name ("12 января" / "January 12"), and "end of
+ * <month>" phrasing. Produces calendarDate/availabilityDate/
+ * availabilityUntil/deadline/publicationDate candidates depending on
+ * nearby from/until wording and domain context (see dateEntityType).
+ */
+
+const MONTH_NAMES = Object.freeze(Object.keys(HIRING_MONTHS).sort((a, b) => b.length - a.length).join('|'));
+const DATE_WORD_RE = new RegExp(`(?<![\\p{L}\\p{N}])(\\d{1,2})\\s+(${MONTH_NAMES})(?:\\s+(20\\d{2}))?(?![\\p{L}\\p{N}])`, 'iu');
+const DATE_MONTH_FIRST_RE = new RegExp(`(?<![\\p{L}\\p{N}])(${MONTH_NAMES})\\s+(\\d{1,2})(?:,?\\s+(20\\d{2}))?(?![\\p{L}\\p{N}])`, 'iu');
+const DATE_NUMERIC_RE = /(?<!\d)(?:(20\d{2})-(\d{1,2})-(\d{1,2})|(\d{1,2})[./](\d{1,2})[./](20\d{2}))(?!\d)/u;
+const DATE_NUMERIC_PARTIAL_RE = /(?<![\d.])(\d{1,2})[./](\d{1,2})(?![\d.])/u;
+const END_OF_MONTH_RE = new RegExp(`(?<![\\p{L}\\p{N}])(?:до|until|p[âa]nă\\s+la|gacha|дейін|чейин|available\\s+until)\\s+(?:конца|кінця|sf[âa]rșit(?:ul)?(?:\\s+lunii)?|end\\s+of)\\s+(${MONTH_NAMES})(?:\\s+(20\\d{2}))?(?![\\p{L}\\p{N}])`, 'giu');
+const START_OF_MONTH_RE = /(?<![\p{L}\p{N}])(?:с|з|from|din|dan|бастап|баштап)\s+(?:начала\s+месяца|початку\s+місяця|începutul\s+lunii|start\s+of\s+(?:the\s+)?month|1(?:-го)?\s+числа|первого\s+числа|1(?:-го)?\s+числа\s+місяця)(?![\p{L}\p{N}])/giu;
+const NEXT_MONTH_RE = /(?<![\p{L}\p{N}])(?:next\s+month|со?\s+следующего\s+месяца|з\s+наступного\s+місяця)(?![\p{L}\p{N}])/giu;
+
+function dateAtMonthEnd(year, month) { return dateValue(year, month, new Date(Date.UTC(year, month, 0)).getUTCDate()); }
+function dateAtNextMonthStart(reference) { const month = reference.getUTCMonth() + 2; const year = reference.getUTCFullYear() + Math.floor((month - 1) / 12); return dateValue(year, ((month - 1) % 12) + 1, 1); }
+
+export function extractCalendarDateCandidates(text, context = {}) {
+  const candidates = [];
+  for (const match of text.matchAll(new RegExp(DATE_NUMERIC_RE, 'gu'))) {
+    const date = match[1] ? dateValue(Number(match[1]), Number(match[2]), Number(match[3])) : dateValue(Number(match[6]), Number(match[5]), Number(match[4]));
+    if (validDate(date)) candidates.push(candidate(dateEntityType(text, match.index ?? 0, context), date, match, 'temporal.calendar.numeric', .98, [{ type: 'regex', rule: 'numeric-date' }]));
+  }
+  for (const match of text.matchAll(new RegExp(DATE_NUMERIC_PARTIAL_RE, 'gu'))) {
+    const start = match.index ?? 0; const around = text.slice(Math.max(0, start - 40), start + match[0].length + 40);
+    if (!/(?:deadline|apply\s+by|closing\s+date|дедлайн|срок(?:\s+подачи)?|термін(?:\s+подання)?|свобод|доступ|заезд|заезж|available|move[- ]?in|(?<![\p{L}\p{N}])(?:с|до|from|until)(?![\p{L}\p{N}]))/iu.test(around)) continue;
+    const relation = relationNear(text, start); const inferred = true;
+    const date = dateValue(inferYear(Number(match[2]), Number(match[1]), relation, context), Number(match[2]), Number(match[1]));
+    if (validDate(date)) candidates.push(candidate(dateEntityType(text, start, context, relation), date, match, 'temporal.calendar.numeric-partial', .86, [{ type: 'regex', rule: 'numeric-partial-date' }, ...inferredDateEvidence(inferred, context)]));
+  }
+  for (const match of text.matchAll(new RegExp(DATE_WORD_RE, 'giu'))) {
+    const monthIndex = HIRING_MONTHS[match[2].toLocaleLowerCase('ru')]; if (monthIndex == null) continue;
+    const relation = relationNear(text, match.index ?? 0); const inferred = !match[3]; const date = dateValue(inferred ? inferYear(monthIndex + 1, Number(match[1]), relation, context) : Number(match[3]), monthIndex + 1, Number(match[1]));
+    if (validDate(date)) candidates.push(candidate(dateEntityType(text, match.index ?? 0, context, relation), date, match, 'temporal.calendar.month-name', inferred ? .88 : .96, [{ type: 'dictionary', dictionary: 'months', key: match[2] }, ...inferredDateEvidence(inferred, context)]));
+  }
+  for (const match of text.matchAll(new RegExp(DATE_MONTH_FIRST_RE, 'giu'))) {
+    const monthIndex = HIRING_MONTHS[match[1].toLocaleLowerCase('ru')]; if (monthIndex == null) continue;
+    const relation = relationNear(text, match.index ?? 0); const inferred = !match[3]; const date = dateValue(inferred ? inferYear(monthIndex + 1, Number(match[2]), relation, context) : Number(match[3]), monthIndex + 1, Number(match[2]));
+    if (validDate(date)) candidates.push(candidate(dateEntityType(text, match.index ?? 0, context, relation), date, match, 'temporal.calendar.month-first', inferred ? .88 : .96, [{ type: 'dictionary', dictionary: 'months', key: match[1] }, ...inferredDateEvidence(inferred, context)]));
+  }
+  for (const match of text.matchAll(END_OF_MONTH_RE)) {
+    const monthIndex = HIRING_MONTHS[match[1].toLocaleLowerCase('ru')]; if (monthIndex == null) continue;
+    const inferred = !match[2]; const year = inferred ? inferYear(monthIndex + 1, 1, 'until', context) : Number(match[2]);
+    candidates.push(candidate('availabilityUntil', dateAtMonthEnd(year, monthIndex + 1), match, 'temporal.calendar.month-end', inferred ? .86 : .94, [{ type: 'dictionary', dictionary: 'months', key: match[1] }, { type: 'relation', value: 'until-month-end' }, ...inferredDateEvidence(inferred, context)]));
+  }
+  for (const match of text.matchAll(START_OF_MONTH_RE)) {
+    const reference = referenceDate(context); const date = dateValue(reference.getUTCFullYear(), reference.getUTCMonth() + 1, 1);
+    candidates.push(candidate(temporalContextType(text, match.index ?? 0, context), date, match, 'temporal.relative.month-start', .88, [{ type: 'context', value: 'month-start' }, { type: 'reference-date', value: referenceEntry(context).source }]));
+  }
+  for (const match of text.matchAll(NEXT_MONTH_RE)) {
+    const date = dateAtNextMonthStart(referenceDate(context));
+    candidates.push(candidate(temporalContextType(text, match.index ?? 0, context), date, match, 'temporal.relative.next-month', .88, [{ type: 'context', value: 'next-month' }, { type: 'reference-date', value: referenceEntry(context).source }]));
+  }
+  return candidates;
+}

package/src/temporal-clock.js

@@ -0,0 +1,46 @@
+import { SCHEDULE_CONTEXT_RE } from './temporal-schedule.js';
+import { candidate } from './temporal-shared.js';
+
+/**
+ * ClockTimeParser + TimeRangeRefiner: a time-of-day ("07:00", "7 утра")
+ * and time ranges ("с 07.00 до 19.00", "22:00-06:00", detecting an
+ * overnight range that crosses midnight). A bare clock time is only kept
+ * when it carries an am/pm-style suffix or nearby schedule-context
+ * wording — otherwise a bare "7" is at least as likely to be a price or
+ * an unrelated number, so it stays unresolved.
+ */
+
+export const TIME_SUFFIX = String.raw`(?:am|pm|утра|вечера|ранку|вечора|ertalab|kechqurun)`;
+const TIME_RE = new RegExp(String.raw`(?<![\d.:])(\d{1,2})(?:[:.](\d{2}))?\s*(${TIME_SUFFIX})?(?![\d.:])`, 'iu');
+const TIME_RANGE_RE = new RegExp(String.raw`(?:с|з|from|dan)?\s*(\d{1,2}(?:[:.]\d{2})?\s*${TIME_SUFFIX}?)\s*(?:до|to|gacha|дейін|чейин|-|–|—)\s*(\d{1,2}(?:[:.]\d{2})?\s*${TIME_SUFFIX}?)`, 'iu');
+
+export function parseClock(raw) { const match = String(raw).trim().match(new RegExp(String.raw`^(\d{1,2})(?:[:.](\d{2}))?\s*(${TIME_SUFFIX})?$`, 'iu')); if (!match) return null; let hour = Number(match[1]); const minute = Number(match[2] || 0); const suffix = String(match[3] || '').toLowerCase(); if (suffix === 'pm' && hour < 12) hour += 12; if (suffix === 'am' && hour === 12) hour = 0; if (/(?:вечера|вечора|kechqurun)/u.test(suffix) && hour < 12) hour += 12; return hour < 24 && minute < 60 ? Object.freeze({ hour, minute }) : null; }
+
+function isTimeRangeContextual(match, text) {
+  if (/[.:]|\b(?:am|pm|утра|вечера|ранку|вечора|ertalab|kechqurun)\b/iu.test(match[0])) return true;
+  if (/^\s*(?:с|from)\b/iu.test(match[0])) return true;
+  const start = match.index ?? 0;
+  return SCHEDULE_CONTEXT_RE.test(text.slice(Math.max(0, start - 32), start + match[0].length + 32));
+}
+function isClockContextual(match, text) {
+  if (/(?:am|pm|утра|вечера|ранку|вечора|ertalab|kechqurun)/iu.test(match[0])) return true;
+  const start = match.index ?? 0;
+  return SCHEDULE_CONTEXT_RE.test(text.slice(Math.max(0, start - 24), start + match[0].length + 24));
+}
+
+export function extractClockCandidates(text) {
+  const candidates = [];
+  const timeRangeSpans = [];
+  for (const match of text.matchAll(new RegExp(TIME_RANGE_RE, 'giu'))) {
+    const start = parseClock(match[1]); const end = parseClock(match[2]);
+    if (!start || !end || !isTimeRangeContextual(match, text)) continue;
+    timeRangeSpans.push([match.index ?? 0, (match.index ?? 0) + match[0].length]);
+    candidates.push(candidate('timeRange', Object.freeze({ start, end, crossesMidnight: start.hour * 60 + start.minute > end.hour * 60 + end.minute }), match, 'temporal.time-range', .98, [{ type: 'range', value: 'clock-time' }]));
+  }
+  for (const match of text.matchAll(new RegExp(TIME_RE, 'giu'))) {
+    const start = match.index ?? 0; const end = start + match[0].length;
+    if (timeRangeSpans.some(([rangeStart, rangeEnd]) => start >= rangeStart && end <= rangeEnd) || !isClockContextual(match, text)) continue;
+    const clock = parseClock(match[0]); if (clock) candidates.push(candidate('clockTime', clock, match, 'temporal.clock-time', .94, [{ type: 'clock', value: 'explicit' }]));
+  }
+  return candidates;
+}

package/src/temporal-duration.js

@@ -0,0 +1,44 @@
+import { candidate } from './temporal-shared.js';
+
+/**
+ * DurationParser: a length of time with an optional bound (min/max/exact)
+ * — "3 месяца", "от 3х мес.", "минимум 3 месяца", "на полгода". Semantic
+ * purpose (rental duration vs probation vs contract vs generic) is
+ * resolved by semanticDurationType from surrounding context, not by the
+ * raw duration reading itself.
+ */
+
+const DURATION_PREFIX = String.raw`(?:от|минимум|не\s+менее|kamida|eng\s+kam|кемінде|не\s+менш(?:е)?|at\s+least|до|не\s+более|ko'?pi\s+bilan|көп\s+емес|на|uchun|pe\s+o\s+perioadă\s+de)`;
+const DURATION_UNIT = String.raw`(?:полгода|год(?:а|ов)?|yil(?:ga)?|жыл(?:ға)?|рок(?:и|ів)?|an(?:i)?|месяц(?:а|ев)?|мес\.?|oy(?:ga)?|місяц(?:і|ів|я)?|luni?|недел[ьяи]|hafta(?:ga)?|апта(?:ға)?|тиж(?:день|ні|нів|ня)|săptămân\p{L}*|saptaman\p{L}*|дн(?:я|ей)?|день|kun(?:ga)?|күн(?:ге)?|день|днів|дні|zi(?:le)?|час(?:а|ов)?|soat(?:ga)?|сағат(?:қа)?|годин(?:а|и|у)?|ore?|мин(?:ут[аы]?|\.)?|daqiqa|минут\p{L}*|minute?)`;
+const DURATION_RE = new RegExp(String.raw`(?<![\p{L}\p{N}])(?:(` + DURATION_PREFIX + String.raw`)(?:\s+на)?\s*)?(` + DURATION_UNIT + String.raw`)(?:\s*)?(\d+(?:[.,]\d+)?)?(?![\p{L}\p{N}])`, 'iu');
+const DURATION_NUMBER_FIRST_RE = new RegExp(String.raw`(?<![\p{L}\p{N}])(?:(` + DURATION_PREFIX + String.raw`)(?:\s+на)?\s*)?(\d+(?:[.,]\d+)?)(?:-?х)?\s*(` + DURATION_UNIT + String.raw`)(?![\p{L}\p{N}])`, 'iu');
+
+function durationValue(prefix, amount, unit) { const normalized = String(unit).toLowerCase(); const value = normalized === 'полгода' ? .5 : Number(amount || 1); const canonicalUnit = /год|year|yil|жыл|рок|\ban/i.test(normalized) || normalized === 'полгода' ? 'year' : /месяц|мес|month|\boy|місяц|lun/i.test(normalized) ? 'month' : /нед|week|hafta|апта|тиж|săptăm|saptaman/i.test(normalized) ? 'week' : /дн|день|day|\bkun|күн|zi/i.test(normalized) ? 'day' : /мин|minute|daqiqa/i.test(normalized) ? 'minute' : 'hour'; const bound = /от|минимум|не\s+менее|kamida|eng\s+kam|кемінде|не\s+менш|at\s+least/iu.test(prefix || '') ? 'min' : /до|не\s+более|ko'?pi\s+bilan|көп\s+емес/iu.test(prefix || '') ? 'max' : 'exact'; return Object.freeze({ value, unit: canonicalUnit, bound }); }
+
+function semanticDurationType(text, start, duration) {
+  const before = text.slice(Math.max(0, start - 56), start);
+  const after = text.slice(start, Math.min(text.length, start + 56));
+  if (/(?:испытательн(?:ый)?\s+срок|probation)[^.;\n]{0,30}$/iu.test(before)) return 'probationDuration';
+  if (/(?:контракт|contract)[^.;\n]{0,30}$/iu.test(before)) return 'contractDuration';
+  if (/(?:сда[её]т|квартир|аренд|ijara|rent|ijaraga\s+beril|оренд)[^.;\n]{0,45}$/iu.test(before) || /(?:сда[её]т|квартир|аренд|ijara|rent|ijaraga\s+beril|оренд)/iu.test(after)) {
+    if (duration?.bound === 'max') return 'maximumRentalDuration';
+    if (duration?.bound === 'exact') return 'fixedRentalDuration';
+    return 'minimumRentalDuration';
+  }
+  return 'duration';
+}
+
+export function extractDurationCandidates(text) {
+  const candidates = [];
+  for (const match of text.matchAll(new RegExp(DURATION_NUMBER_FIRST_RE, 'giu'))) { const value = durationValue(match[1], match[2], match[3]); candidates.push(candidate(semanticDurationType(text, match.index ?? 0, value), value, match, 'temporal.duration.number-unit', .95, [{ type: 'unit', value: match[3] }, ...(match[1] ? [{ type: 'prefix', value: match[1] }] : [])])); }
+  for (const match of text.matchAll(new RegExp(DURATION_RE, 'giu'))) {
+    if (match[3]) continue;
+    // Bare genitive "дня" is almost always part of another phrase ("конца
+    // дня", "сегодняшнего дня", "через 2 дня") rather than a standalone
+    // 1-day duration. Only accept it here when an explicit duration prefix
+    // ("на", "минимум", ...) makes the duration reading unambiguous.
+    if (!match[1] && /^дня$/iu.test(match[2])) continue;
+    const value = durationValue(match[1], match[3], match[2]); candidates.push(candidate(semanticDurationType(text, match.index ?? 0, value), value, match, 'temporal.duration.word-unit', .94, [{ type: 'unit', value: match[2] }, ...(match[1] ? [{ type: 'prefix', value: match[1] }] : [])]));
+  }
+  return candidates;
+}

package/src/temporal-relative-date.js

@@ -0,0 +1,38 @@
+import { nextWeekday, DAY_ALIASES, DAY_PATTERN } from './temporal-weekday.js';
+import { addUtcDays, candidate, referenceDate, referenceEntry, temporalContextType } from './temporal-shared.js';
+
+/**
+ * RelativeDateParser: dates expressed relative to the reference date —
+ * "сегодня"/"завтра"/"через 3 дня", and "next <weekday>". Semantic role
+ * (availabilityDate/startDate/plain relativeDate) is assigned by
+ * temporalContextType based on nearby wording, not by this parser.
+ */
+
+const RELATIVE_RE = /(?<![\p{L}\p{N}])(?:с\s+|з\s+|dan\s+)?(послезавтрашн\p{L}*\s+дн\p{L}*|сегодняшн\p{L}*\s+дн\p{L}*|завтрашн\p{L}*\s+дн\p{L}*|післязавтрашн\p{L}*\s+дн\p{L}*|сьогоднішн\p{L}*\s+дн\p{L}*|сегодня|завтра|послезавтра|сьогодні|післязавтра|bugun|ertaga|indin|бүгін|ертең|бүрсігүні|бүгүн|эртең|бүрсүгүнү|astăzi|azi|mâine|maine|poimâine|poimaine|today|tomorrow|day\s+after\s+tomorrow|через\s+(\d+|неделю|две\s+недели)\s*(?:дн(?:я|ей)?|день|недел[ьюи])?)(?![\p{L}\p{N}])/giu;
+const EXTENDED_RELATIVE_RE = /(?<![\p{L}\p{N}])(?:через\s+(\d+)\s+(дні|днів|тижд(?:ень|ні|нів|ня))|peste\s+(\d+)\s+(zile?|săptămân(?:ă|i)|saptaman(?:a|i))|(\d+)\s+(күннен|аптадан|кун(?:дөн|дон)|жумадан)\s+(?:кейін|кийин))(?![\p{L}\p{N}])/giu;
+const NEXT_WEEKDAY_RE = new RegExp(`(?<![\\p{L}\\p{N}])(?:со?\\s+следующ(?:его|ей)\\s+|з\\s+наступн(?:ого|ої)\\s+|next\\s+)(${DAY_PATTERN})(?![\\p{L}\\p{N}])`, 'giu');
+
+function relativeDays(raw) { const lower = raw.toLowerCase(); if (/сегодня|сьогодні|bugun|бүгін|бүгүн|astăzi|azi|today/u.test(lower)) return 0; if (/послезавтра|післязавтра|indin|бүрсігүні|бүрсүгүнү|poimâine|poimaine|day\s+after/u.test(lower)) return 2; if (/завтра|ertaga|ертең|эртең|mâine|maine|tomorrow/u.test(lower)) return 1; if (/две\s+недели/u.test(lower)) return 14; if (/неделю/u.test(lower)) return 7; const numeric = Number(lower.match(/\d+/u)?.[0]); return Number.isFinite(numeric) ? numeric : null; }
+function relativeDurationDays(amount, unit) {
+  const value = Number(amount);
+  if (!Number.isFinite(value) || value < 0) return null;
+  return /(?:тиж|săptăm|saptaman|апта|жума)/iu.test(unit) ? value * 7 : value;
+}
+
+export function extractRelativeDateCandidates(text, context = {}) {
+  const candidates = [];
+  for (const match of text.matchAll(NEXT_WEEKDAY_RE)) {
+    const weekday = DAY_ALIASES[match[1].toLowerCase()]; if (weekday == null) continue;
+    candidates.push(candidate(temporalContextType(text, match.index ?? 0, context), nextWeekday(referenceDate(context), weekday), match, 'temporal.relative.next-weekday', .9, [{ type: 'dictionary', dictionary: 'weekdays', key: match[1] }, { type: 'reference-date', value: referenceEntry(context).source }]));
+  }
+  for (const match of text.matchAll(RELATIVE_RE)) { const days = relativeDays(match[1]); if (days == null) continue; const type = temporalContextType(text, match.index ?? 0, context); candidates.push(candidate(type, addUtcDays(referenceDate(context), days), match, 'temporal.relative-date', .91, [{ type: 'context', value: `relative:${days}d` }, { type: 'reference-date', value: referenceEntry(context).source }])); }
+  for (const match of text.matchAll(EXTENDED_RELATIVE_RE)) {
+    const amount = match[1] || match[3] || match[5];
+    const unit = match[2] || match[4] || match[6];
+    const days = relativeDurationDays(amount, unit);
+    if (days == null) continue;
+    const type = temporalContextType(text, match.index ?? 0, context);
+    candidates.push(candidate(type, addUtcDays(referenceDate(context), days), match, 'temporal.relative-date.extended', .91, [{ type: 'context', value: `relative:${days}d` }, { type: 'unit', value: unit }, { type: 'reference-date', value: referenceEntry(context).source }]));
+  }
+  return candidates;
+}

package/src/temporal-schedule.js

@@ -0,0 +1,65 @@
+import { DAY_ALIASES, DAY_PATTERN, WEEKDAYS } from './temporal-weekday.js';
+import { candidate } from './temporal-shared.js';
+
+/**
+ * ScheduleCycleParser + WeekdayParser + multiple-shifts: work-schedule
+ * cycles ("2/2", "два через два"), fixed weekday ranges ("Пн-Пт"), named
+ * weekday sets ("по будням"/"только по выходным"), and multi-shift
+ * listings ("1 смена 07:00-15:00 ... 2 смена ..."). A bare "N/M" ratio is
+ * only read as a schedule when SCHEDULE_CONTEXT_RE finds nearby work-
+ * schedule language — otherwise it stays ambiguous (never assumed to be a
+ * schedule by default).
+ */
+
+export const SCHEDULE_CONTEXT_RE = /(?:график|смен[аы]|режим\s+работы|work\s*schedule|shift|работ[аы]|job|графік|змін[аи]|program(?:ul)?\s+de\s+lucru|ish\s+grafigi|жұмыс\s+кестесі|жумуш\s+графиги)/iu;
+const WEEKDAY_RANGE_RE = new RegExp(`(?<![\\p{L}\\p{N}])(${DAY_PATTERN})\\s*(?:-|–|—|до|to|по)\\s*(${DAY_PATTERN})(?![\\p{L}\\p{N}])`, 'giu');
+const SHIFT_RE = /(?<!\d)(\d{1,2})\s*(?:смен[аы]|shift)\s*(\d{1,2}(?:[:.]\d{2})?\s*(?:am|pm|утра|вечера)?)\s*(?:-|–|—|до|to)\s*(\d{1,2}(?:[:.]\d{2})?\s*(?:am|pm|утра|вечера)?)/giu;
+
+function scheduleDaysOffMode(text) {
+  if (/(?:плавающ|floating|flexible\s+days\s+off)/iu.test(text)) return 'floating';
+  if (/(?:скользящ|сменн|rotating\s+days\s+off|выходные\s+по\s+графику)/iu.test(text)) return 'rotating';
+  return 'fixed';
+}
+function cycleScheduleValue(work, rest, daysOffMode) {
+  // Day cycles such as 2/2 and 5/2 are common. Values larger than a week in
+  // an explicit schedule context are the conventional shift notation 24/48
+  // or 12/24, not a claim of dozens of working days.
+  if (Math.max(work, rest) > 7) {
+    // An hour cycle has no fixed weekday rest days. Keep an explicitly
+    // floating mode, otherwise expose the inherent repeating rotation.
+    return Object.freeze({ type: 'cycle', cycleHours: Object.freeze({ work, rest }), daysOffMode: daysOffMode === 'fixed' ? 'rotating' : daysOffMode });
+  }
+  return Object.freeze({ type: 'cycle', workDays: work, restDays: rest, daysOffMode });
+}
+
+export function extractScheduleCandidates(text, parseClock) {
+  const candidates = [];
+  const scheduleContext = SCHEDULE_CONTEXT_RE;
+  for (const match of text.matchAll(/(?<![\d:.])(\d{1,2})\s*(?:\/|\\|через|-)\s*(\d{1,2})(?![\d:.])/giu)) {
+    const around = text.slice(Math.max(0, (match.index ?? 0) - 32), (match.index ?? 0) + match[0].length + 32); if (!scheduleContext.test(around)) continue;
+    const daysOffMode = scheduleDaysOffMode(around);
+    const work = Number(match[1]); const rest = Number(match[2]);
+    candidates.push(candidate('workSchedule', cycleScheduleValue(work, rest, daysOffMode), match, 'temporal.schedule-cycle', .99, [{ type: 'context', value: 'schedule' }, { type: 'range', value: Math.max(work, rest) > 7 ? 'cycle-hours' : 'cycle' }, { type: 'days-off-mode', value: daysOffMode }]));
+  }
+  for (const match of text.matchAll(/(?<![\p{L}\p{N}])два\s+через\s+два(?![\p{L}\p{N}])/giu)) {
+    const around = text.slice(Math.max(0, (match.index ?? 0) - 32), (match.index ?? 0) + match[0].length + 32); if (!scheduleContext.test(around)) continue;
+    const daysOffMode = scheduleDaysOffMode(around);
+    candidates.push(candidate('workSchedule', Object.freeze({ type: 'cycle', workDays: 2, restDays: 2, daysOffMode }), match, 'temporal.schedule-cycle.words', .97, [{ type: 'context', value: 'schedule' }, { type: 'range', value: 'cycle' }, { type: 'days-off-mode', value: daysOffMode }]));
+  }
+  for (const match of text.matchAll(WEEKDAY_RANGE_RE)) {
+    const start = DAY_ALIASES[match[1].toLowerCase()]; const end = DAY_ALIASES[match[2].toLowerCase()];
+    if (start == null || end == null || end < start) continue;
+    candidates.push(candidate('workSchedule', Object.freeze({ type: 'weekdays', workingDays: WEEKDAYS.slice(start, end + 1), daysOffMode: 'fixed' }), match, 'temporal.schedule-weekdays', .97, [{ type: 'range', value: 'weekday' }]));
+  }
+  for (const match of text.matchAll(/(?<![\p{L}\p{N}])(?:по\s+будням|weekdays?)(?![\p{L}\p{N}])/giu)) {
+    candidates.push(candidate('workSchedule', Object.freeze({ type: 'weekdays', workingDays: WEEKDAYS.slice(0, 5), daysOffMode: 'fixed' }), match, 'temporal.schedule-weekdays.named', .96, [{ type: 'context', value: 'weekdays' }]));
+  }
+  for (const match of text.matchAll(/(?<![\p{L}\p{N}])(?:только\s+по\s+выходным|weekends?\s+only)(?![\p{L}\p{N}])/giu)) {
+    candidates.push(candidate('workSchedule', Object.freeze({ type: 'weekdays', workingDays: WEEKDAYS.slice(5), daysOffMode: 'fixed' }), match, 'temporal.schedule-weekends', .96, [{ type: 'context', value: 'weekends' }]));
+  }
+  const shifts = [];
+  let firstShift = null; let lastShift = null;
+  for (const match of text.matchAll(SHIFT_RE)) { const start = parseClock(match[2]); const end = parseClock(match[3]); if (!start || !end) continue; firstShift ||= match; lastShift = match; shifts.push(Object.freeze({ name: `${match[1]} shift`, hours: Object.freeze({ start, end, crossesMidnight: start.hour * 60 + start.minute > end.hour * 60 + end.minute }) })); }
+  if (shifts.length) candidates.push(candidate('shifts', Object.freeze(shifts), { 0: text.slice(firstShift.index, (lastShift.index ?? 0) + lastShift[0].length), index: firstShift.index }, 'temporal.multiple-shifts', .98, [{ type: 'context', value: 'shift' }, { type: 'range', value: 'clock-time' }]));
+  return candidates;
+}

package/src/temporal-shared.js

@@ -0,0 +1,54 @@
+import { createParseCandidate } from './parser-core.js';
+
+/**
+ * Helpers shared by every temporal sub-parser (calendar dates, relative
+ * dates, durations, clock/schedule). Kept in one place so reference-date
+ * resolution, candidate construction and from/until relation detection
+ * cannot drift between parsers.
+ */
+
+export function referenceEntry(context = {}) {
+  for (const [source, value] of [['referenceDate', context.referenceDate], ['publishedAt', context.publishedAt], ['fetchedAt', context.fetchedAt]]) {
+    if (value == null || value === '') continue;
+    const date = new Date(value);
+    if (Number.isFinite(date.getTime())) return Object.freeze({ date, source });
+  }
+  return Object.freeze({ date: new Date(), source: 'currentDate' });
+}
+export function referenceDate(context = {}) { return referenceEntry(context).date; }
+export function dateValue(year, month, day) { return Object.freeze({ year, month, day }); }
+export function validDate(value) { const date = new Date(Date.UTC(value.year, value.month - 1, value.day)); return date.getUTCFullYear() === value.year && date.getUTCMonth() === value.month - 1 && date.getUTCDate() === value.day; }
+export function candidate(entityType, value, match, parser, confidence, evidence) { const start = match.index ?? 0; return createParseCandidate({ id: `${entityType}:${start}`, entityType, value, raw: match[0], start, end: start + match[0].length, parser, confidence, evidence }); }
+
+// Bare "с"/"з"/"до" are single Cyrillic letters and match as a substring of
+// countless ordinary words ("Сдаю", "доступна") without a boundary guard —
+// "Сдаю до 15.03" was misread as 'from' off the "С" in "Сдаю" alone, hiding
+// the actual "до" (until) marker that followed.
+const RELATION_FROM_RE = /(?<![\p{L}\p{N}])(?:с|з|from|din|dan|бастап|баштап|доступна\s+(?:с|з)|заезд\s+(?:с|з))(?![\p{L}\p{N}])/iu;
+const RELATION_UNTIL_RE = /(?<![\p{L}\p{N}])(?:до|until|p[âa]nă\s+la|gacha|дейін|чейин|не\s+позднее)(?![\p{L}\p{N}])/iu;
+export function relationNear(text, start) { const before = text.slice(Math.max(0, start - 32), start); return RELATION_FROM_RE.test(before) ? 'from' : RELATION_UNTIL_RE.test(before) ? 'until' : 'exact'; }
+
+// A year-less date is assumed to refer to its next occurrence when the
+// current year's reading has already passed — not just for explicit
+// "from"/"until" wording. A bare mention with no relation ('exact') is the
+// common case (e.g. "12 января встреча") and would otherwise silently
+// resolve to a date up to a year in the past.
+export function inferYear(month, day, relation, context) { const reference = referenceDate(context); let year = reference.getUTCFullYear(); const candidateDate = Date.UTC(year, month - 1, day); if (candidateDate < reference.getTime() - 36 * 3_600_000) year += 1; return year; }
+
+export function inferredDateEvidence(inferred, context) { return inferred ? [{ type: 'inferred-year', reference: referenceEntry(context).source }] : []; }
+
+export function dateEntityType(text, start, context, relation = relationNear(text, start)) {
+  const around = text.slice(Math.max(0, start - 48), Math.min(text.length, start + 48));
+  if (/(?:deadline|apply\s+by|closing\s+date|дедлайн|срок(?:\s+подачи)?|термін(?:\s+подання)?)/iu.test(around)) return 'deadline';
+  if (/(?:published|publication|опубликован|опублікован)/iu.test(around)) return 'publicationDate';
+  // Direction must belong to this date's local left context. Looking ahead
+  // across a whole listing makes "available from 12 February, until March"
+  // incorrectly classify the February date as an end date.
+  if (relation === 'until') return 'availabilityUntil';
+  if (relation === 'from' || (context.domain === 'real-estate' && /(?:свобод|доступ|заезд|заезж|ijara|bo['’`]?sh|вільн|disponibil|move[- ]?in|available)/iu.test(around))) return 'availabilityDate';
+  return 'calendarDate';
+}
+
+export function temporalContextType(text, start, context) { const around = text.slice(Math.max(0, start - 48), Math.min(text.length, start + 48)); if (/(?:свобод|доступ|заезд|заезж|ijara|bo['’`]?sh|бос|бош|вільн|disponibil|move[- ]?in|available)/iu.test(around)) return 'availabilityDate'; if ((context.domain === 'vacancy' || /(?:ваканс|работ|job|ish\s+grafigi|графік)/iu.test(around)) && /(?:выход|start|приступ|boshlash)/iu.test(around)) return 'startDate'; return 'relativeDate'; }
+
+export function addUtcDays(date, days) { const copy = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate() + days)); return dateValue(copy.getUTCFullYear(), copy.getUTCMonth() + 1, copy.getUTCDate()); }

package/src/temporal-weekday.js

@@ -0,0 +1,17 @@
+import { addUtcDays } from './temporal-shared.js';
+
+/** Weekday vocabulary shared by RelativeDateParser (next-weekday) and ScheduleCycleParser (weekday ranges). */
+
+export const WEEKDAYS = Object.freeze(['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']);
+export const DAY_ALIASES = Object.freeze({
+  пн: 0, понедельник: 0, понедельника: 0, понеділок: 0, понеділка: 0, mon: 0, monday: 0, dushanba: 0, дүйсенбі: 0, дүйшөмбү: 0, luni: 0,
+  вт: 1, вторник: 1, вторника: 1, вівторок: 1, вівторка: 1, tue: 1, tuesday: 1, seshanba: 1, сейсенбі: 1, шейшемби: 1, marți: 1, marti: 1,
+  ср: 2, среда: 2, среды: 2, середа: 2, середи: 2, wed: 2, wednesday: 2, chorshanba: 2, сәрсенбі: 2, шаршемби: 2, miercuri: 2,
+  чт: 3, четверг: 3, четверга: 3, четвер: 3, четверга: 3, thu: 3, thursday: 3, payshanba: 3, бейсенбі: 3, бейшемби: 3, joi: 3,
+  пт: 4, пятница: 4, пятницы: 4, "п'ятниця": 4, 'п’ятниця': 4, пятниця: 4, fri: 4, friday: 4, juma: 4, жұма: 4, жума: 4, vineri: 4,
+  сб: 5, суббота: 5, субботы: 5, субота: 5, sat: 5, saturday: 5, shanba: 5, сенбі: 5, ишемби: 5, sâmbătă: 5, sambata: 5,
+  вс: 6, воскресенье: 6, воскресенья: 6, неділя: 6, неділю: 6, sun: 6, sunday: 6, yakshanba: 6, жексенбі: 6, жекшемби: 6, duminică: 6, duminica: 6,
+});
+export const DAY_PATTERN = Object.keys(DAY_ALIASES).sort((a, b) => b.length - a.length).join('|');
+
+export function nextWeekday(date, weekday) { const current = (date.getUTCDay() + 6) % 7; let days = (weekday - current + 7) % 7; if (days === 0) days = 7; return addUtcDays(date, days); }

package/src/temporal.js

@@ -1,229 +1,32 @@
-import { HIRING_MONTHS } from './hiring-temporal.js';
-import { createParseCandidate, resolveParseCandidates } from './parser-core.js';
+import { resolveParseCandidates } from './parser-core.js';
+import { extractCalendarDateCandidates } from './temporal-calendar-date.js';
+import { extractRelativeDateCandidates } from './temporal-relative-date.js';
+import { extractDurationCandidates } from './temporal-duration.js';
+import { extractClockCandidates, parseClock } from './temporal-clock.js';
+import { extractScheduleCandidates } from './temporal-schedule.js';
 
-const MONTH_NAMES = Object.freeze(Object.keys(HIRING_MONTHS).sort((a, b) => b.length - a.length).join('|'));
-const DATE_WORD_RE = new RegExp(`(?<![\\p{L}\\p{N}])(\\d{1,2})\\s+(${MONTH_NAMES})(?:\\s+(20\\d{2}))?(?![\\p{L}\\p{N}])`, 'iu');
-const DATE_MONTH_FIRST_RE = new RegExp(`(?<![\\p{L}\\p{N}])(${MONTH_NAMES})\\s+(\\d{1,2})(?:,?\\s+(20\\d{2}))?(?![\\p{L}\\p{N}])`, 'iu');
-const DATE_NUMERIC_RE = /(?<!\d)(?:(20\d{2})-(\d{1,2})-(\d{1,2})|(\d{1,2})[./](\d{1,2})[./](20\d{2}))(?!\d)/u;
-const DATE_NUMERIC_PARTIAL_RE = /(?<![\d.])(\d{1,2})[./](\d{1,2})(?![\d.])/u;
-const TIME_SUFFIX = String.raw`(?:am|pm|утра|вечера|ранку|вечора|ertalab|kechqurun)`;
-const TIME_RE = new RegExp(String.raw`(?<![\d.:])(\d{1,2})(?:[:.](\d{2}))?\s*(${TIME_SUFFIX})?(?![\d.:])`, 'iu');
-const TIME_RANGE_RE = new RegExp(String.raw`(?:с|з|from|dan)?\s*(\d{1,2}(?:[:.]\d{2})?\s*${TIME_SUFFIX}?)\s*(?:до|to|gacha|дейін|чейин|-|–|—)\s*(\d{1,2}(?:[:.]\d{2})?\s*${TIME_SUFFIX}?)`, 'iu');
-const DURATION_PREFIX = String.raw`(?:от|минимум|не\s+менее|kamida|eng\s+kam|кемінде|не\s+менш(?:е)?|at\s+least|до|не\s+более|ko'?pi\s+bilan|көп\s+емес|на|uchun|pe\s+o\s+perioadă\s+de)`;
-const DURATION_UNIT = String.raw`(?:полгода|год(?:а|ов)?|yil(?:ga)?|жыл(?:ға)?|рок(?:и|ів)?|an(?:i)?|месяц(?:а|ев)?|мес\.?|oy(?:ga)?|місяц(?:і|ів|я)?|luni?|недел[ьяи]|hafta(?:ga)?|апта(?:ға)?|тиж(?:день|ні|нів|ня)|săptămân\p{L}*|saptaman\p{L}*|дн(?:я|ей)?|день|kun(?:ga)?|күн(?:ге)?|день|днів|дні|zi(?:le)?|час(?:а|ов)?|soat(?:ga)?|сағат(?:қа)?|годин(?:а|и|у)?|ore?|мин(?:ут[аы]?|\.)?|daqiqa|минут\p{L}*|minute?)`;
-const DURATION_RE = new RegExp(String.raw`(?<![\p{L}\p{N}])(?:(` + DURATION_PREFIX + String.raw`)(?:\s+на)?\s*)?(` + DURATION_UNIT + String.raw`)(?:\s*)?(\d+(?:[.,]\d+)?)?(?![\p{L}\p{N}])`, 'iu');
-const DURATION_NUMBER_FIRST_RE = new RegExp(String.raw`(?<![\p{L}\p{N}])(?:(` + DURATION_PREFIX + String.raw`)(?:\s+на)?\s*)?(\d+(?:[.,]\d+)?)(?:-?х)?\s*(` + DURATION_UNIT + String.raw`)(?![\p{L}\p{N}])`, 'iu');
-const WEEKDAYS = Object.freeze(['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']);
-const DAY_ALIASES = Object.freeze({
-  пн: 0, понедельник: 0, понедельника: 0, понеділок: 0, понеділка: 0, mon: 0, monday: 0, dushanba: 0, дүйсенбі: 0, дүйшөмбү: 0, luni: 0,
-  вт: 1, вторник: 1, вторника: 1, вівторок: 1, вівторка: 1, tue: 1, tuesday: 1, seshanba: 1, сейсенбі: 1, шейшемби: 1, marți: 1, marti: 1,
-  ср: 2, среда: 2, среды: 2, середа: 2, середи: 2, wed: 2, wednesday: 2, chorshanba: 2, сәрсенбі: 2, шаршемби: 2, miercuri: 2,
-  чт: 3, четверг: 3, четверга: 3, четвер: 3, четверга: 3, thu: 3, thursday: 3, payshanba: 3, бейсенбі: 3, бейшемби: 3, joi: 3,
-  пт: 4, пятница: 4, пятницы: 4, "п'ятниця": 4, 'п’ятниця': 4, пятниця: 4, fri: 4, friday: 4, juma: 4, жұма: 4, жума: 4, vineri: 4,
-  сб: 5, суббота: 5, субботы: 5, субота: 5, sat: 5, saturday: 5, shanba: 5, сенбі: 5, ишемби: 5, sâmbătă: 5, sambata: 5,
-  вс: 6, воскресенье: 6, воскресенья: 6, неділя: 6, неділю: 6, sun: 6, sunday: 6, yakshanba: 6, жексенбі: 6, жекшемби: 6, duminică: 6, duminica: 6,
-});
-const RELATIVE_RE = /(?<![\p{L}\p{N}])(?:с\s+|з\s+|dan\s+)?(послезавтрашн\p{L}*\s+дн\p{L}*|сегодняшн\p{L}*\s+дн\p{L}*|завтрашн\p{L}*\s+дн\p{L}*|післязавтрашн\p{L}*\s+дн\p{L}*|сьогоднішн\p{L}*\s+дн\p{L}*|сегодня|завтра|послезавтра|сьогодні|післязавтра|bugun|ertaga|indin|бүгін|ертең|бүрсігүні|бүгүн|эртең|бүрсүгүнү|astăzi|azi|mâine|maine|poimâine|poimaine|today|tomorrow|day\s+after\s+tomorrow|через\s+(\d+|неделю|две\s+недели)\s*(?:дн(?:я|ей)?|день|недел[ьюи])?)(?![\p{L}\p{N}])/giu;
-const EXTENDED_RELATIVE_RE = /(?<![\p{L}\p{N}])(?:через\s+(\d+)\s+(дні|днів|тижд(?:ень|ні|нів|ня))|peste\s+(\d+)\s+(zile?|săptămân(?:ă|i)|saptaman(?:a|i))|(\d+)\s+(күннен|аптадан|кун(?:дөн|дон)|жумадан)\s+(?:кейін|кийин))(?![\p{L}\p{N}])/giu;
-const DAY_PATTERN = Object.keys(DAY_ALIASES).sort((a, b) => b.length - a.length).join('|');
-const WEEKDAY_RANGE_RE = new RegExp(`(?<![\\p{L}\\p{N}])(${DAY_PATTERN})\\s*(?:-|–|—|до|to|по)\\s*(${DAY_PATTERN})(?![\\p{L}\\p{N}])`, 'giu');
-const NEXT_WEEKDAY_RE = new RegExp(`(?<![\\p{L}\\p{N}])(?:со?\\s+следующ(?:его|ей)\\s+|з\\s+наступн(?:ого|ої)\\s+|next\\s+)(${DAY_PATTERN})(?![\\p{L}\\p{N}])`, 'giu');
-const END_OF_MONTH_RE = new RegExp(`(?<![\\p{L}\\p{N}])(?:до|until|p[âa]nă\\s+la|gacha|дейін|чейин|available\\s+until)\\s+(?:конца|кінця|sf[âa]rșit(?:ul)?(?:\\s+lunii)?|end\\s+of)\\s+(${MONTH_NAMES})(?:\\s+(20\\d{2}))?(?![\\p{L}\\p{N}])`, 'giu');
-const START_OF_MONTH_RE = /(?<![\p{L}\p{N}])(?:с|з|from|din|dan|бастап|баштап)\s+(?:начала\s+месяца|початку\s+місяця|începutul\s+lunii|start\s+of\s+(?:the\s+)?month|1(?:-го)?\s+числа|первого\s+числа|1(?:-го)?\s+числа\s+місяця)(?![\p{L}\p{N}])/giu;
-const NEXT_MONTH_RE = /(?<![\p{L}\p{N}])(?:next\s+month|со?\s+следующего\s+месяца|з\s+наступного\s+місяця)(?![\p{L}\p{N}])/giu;
-const SHIFT_RE = /(?<!\d)(\d{1,2})\s*(?:смен[аы]|shift)\s*(\d{1,2}(?:[:.]\d{2})?\s*(?:am|pm|утра|вечера)?)\s*(?:-|–|—|до|to)\s*(\d{1,2}(?:[:.]\d{2})?\s*(?:am|pm|утра|вечера)?)/giu;
-
-function referenceEntry(context = {}) {
-  for (const [source, value] of [['referenceDate', context.referenceDate], ['publishedAt', context.publishedAt], ['fetchedAt', context.fetchedAt]]) {
-    if (value == null || value === '') continue;
-    const date = new Date(value);
-    if (Number.isFinite(date.getTime())) return Object.freeze({ date, source });
-  }
-  return Object.freeze({ date: new Date(), source: 'currentDate' });
-}
-function referenceDate(context = {}) { return referenceEntry(context).date; }
-function dateValue(year, month, day) { return Object.freeze({ year, month, day }); }
-function validDate(value) { const date = new Date(Date.UTC(value.year, value.month - 1, value.day)); return date.getUTCFullYear() === value.year && date.getUTCMonth() === value.month - 1 && date.getUTCDate() === value.day; }
-function candidate(entityType, value, match, parser, confidence, evidence) { const start = match.index ?? 0; return createParseCandidate({ id: `${entityType}:${start}`, entityType, value, raw: match[0], start, end: start + match[0].length, parser, confidence, evidence }); }
-// Bare "с"/"з"/"до" are single Cyrillic letters and match as a substring of
-// countless ordinary words ("Сдаю", "доступна") without a boundary guard —
-// "Сдаю до 15.03" was misread as 'from' off the "С" in "Сдаю" alone, hiding
-// the actual "до" (until) marker that followed.
-const RELATION_FROM_RE = /(?<![\p{L}\p{N}])(?:с|з|from|din|dan|бастап|баштап|доступна\s+(?:с|з)|заезд\s+(?:с|з))(?![\p{L}\p{N}])/iu;
-const RELATION_UNTIL_RE = /(?<![\p{L}\p{N}])(?:до|until|p[âa]nă\s+la|gacha|дейін|чейин|не\s+позднее)(?![\p{L}\p{N}])/iu;
-function relationNear(text, start) { const before = text.slice(Math.max(0, start - 32), start); return RELATION_FROM_RE.test(before) ? 'from' : RELATION_UNTIL_RE.test(before) ? 'until' : 'exact'; }
-// A year-less date is assumed to refer to its next occurrence when the
-// current year's reading has already passed — not just for explicit
-// "from"/"until" wording. A bare mention with no relation ('exact') is the
-// common case (e.g. "12 января встреча") and would otherwise silently
-// resolve to a date up to a year in the past.
-function inferYear(month, day, relation, context) { const reference = referenceDate(context); let year = reference.getUTCFullYear(); const candidateDate = Date.UTC(year, month - 1, day); if (candidateDate < reference.getTime() - 36 * 3_600_000) year += 1; return year; }
-function parseClock(raw) { const match = String(raw).trim().match(new RegExp(String.raw`^(\d{1,2})(?:[:.](\d{2}))?\s*(${TIME_SUFFIX})?$`, 'iu')); if (!match) return null; let hour = Number(match[1]); const minute = Number(match[2] || 0); const suffix = String(match[3] || '').toLowerCase(); if (suffix === 'pm' && hour < 12) hour += 12; if (suffix === 'am' && hour === 12) hour = 0; if (/(?:вечера|вечора|kechqurun)/u.test(suffix) && hour < 12) hour += 12; return hour < 24 && minute < 60 ? Object.freeze({ hour, minute }) : null; }
-function durationValue(prefix, amount, unit) { const normalized = String(unit).toLowerCase(); const value = normalized === 'полгода' ? .5 : Number(amount || 1); const canonicalUnit = /год|year|yil|жыл|рок|\ban/i.test(normalized) || normalized === 'полгода' ? 'year' : /месяц|мес|month|\boy|місяц|lun/i.test(normalized) ? 'month' : /нед|week|hafta|апта|тиж|săptăm|saptaman/i.test(normalized) ? 'week' : /дн|день|day|\bkun|күн|zi/i.test(normalized) ? 'day' : /мин|minute|daqiqa/i.test(normalized) ? 'minute' : 'hour'; const bound = /от|минимум|не\s+менее|kamida|eng\s+kam|кемінде|не\s+менш|at\s+least/iu.test(prefix || '') ? 'min' : /до|не\s+более|ko'?pi\s+bilan|көп\s+емес/iu.test(prefix || '') ? 'max' : 'exact'; return Object.freeze({ value, unit: canonicalUnit, bound }); }
-function semanticDurationType(text, start, duration) {
-  const before = text.slice(Math.max(0, start - 56), start);
-  const after = text.slice(start, Math.min(text.length, start + 56));
-  if (/(?:испытательн(?:ый)?\s+срок|probation)[^.;\n]{0,30}$/iu.test(before)) return 'probationDuration';
-  if (/(?:контракт|contract)[^.;\n]{0,30}$/iu.test(before)) return 'contractDuration';
-  if (/(?:сда[её]т|квартир|аренд|ijara|rent|ijaraga\s+beril|оренд)[^.;\n]{0,45}$/iu.test(before) || /(?:сда[её]т|квартир|аренд|ijara|rent|ijaraga\s+beril|оренд)/iu.test(after)) {
-    if (duration?.bound === 'max') return 'maximumRentalDuration';
-    if (duration?.bound === 'exact') return 'fixedRentalDuration';
-    return 'minimumRentalDuration';
-  }
-  return 'duration';
-}
-function addUtcDays(date, days) { const copy = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate() + days)); return dateValue(copy.getUTCFullYear(), copy.getUTCMonth() + 1, copy.getUTCDate()); }
-function relativeDays(raw) { const lower = raw.toLowerCase(); if (/сегодня|сьогодні|bugun|бүгін|бүгүн|astăzi|azi|today/u.test(lower)) return 0; if (/послезавтра|післязавтра|indin|бүрсігүні|бүрсүгүнү|poimâine|poimaine|day\s+after/u.test(lower)) return 2; if (/завтра|ertaga|ертең|эртең|mâine|maine|tomorrow/u.test(lower)) return 1; if (/две\s+недели/u.test(lower)) return 14; if (/неделю/u.test(lower)) return 7; const numeric = Number(lower.match(/\d+/u)?.[0]); return Number.isFinite(numeric) ? numeric : null; }
-function relativeDurationDays(amount, unit) {
-  const value = Number(amount);
-  if (!Number.isFinite(value) || value < 0) return null;
-  return /(?:тиж|săptăm|saptaman|апта|жума)/iu.test(unit) ? value * 7 : value;
-}
-function temporalContextType(text, start, context) { const around = text.slice(Math.max(0, start - 48), Math.min(text.length, start + 48)); if (/(?:свобод|доступ|заезд|заезж|ijara|bo['’`]?sh|бос|бош|вільн|disponibil|move[- ]?in|available)/iu.test(around)) return 'availabilityDate'; if ((context.domain === 'vacancy' || /(?:ваканс|работ|job|ish\s+grafigi|графік)/iu.test(around)) && /(?:выход|start|приступ|boshlash)/iu.test(around)) return 'startDate'; return 'relativeDate'; }
-function dateEntityType(text, start, context, relation = relationNear(text, start)) {
-  const around = text.slice(Math.max(0, start - 48), Math.min(text.length, start + 48));
-  if (/(?:deadline|apply\s+by|closing\s+date|дедлайн|срок(?:\s+подачи)?|термін(?:\s+подання)?)/iu.test(around)) return 'deadline';
-  if (/(?:published|publication|опубликован|опублікован)/iu.test(around)) return 'publicationDate';
-  // Direction must belong to this date's local left context. Looking ahead
-  // across a whole listing makes "available from 12 February, until March"
-  // incorrectly classify the February date as an end date.
-  if (relation === 'until') return 'availabilityUntil';
-  if (relation === 'from' || (context.domain === 'real-estate' && /(?:свобод|доступ|заезд|заезж|ijara|bo['’`]?sh|вільн|disponibil|move[- ]?in|available)/iu.test(around))) return 'availabilityDate';
-  return 'calendarDate';
-}
-function inferredDateEvidence(inferred, context) { return inferred ? [{ type: 'inferred-year', reference: referenceEntry(context).source }] : []; }
-const SCHEDULE_CONTEXT_RE = /(?:график|смен[аы]|режим\s+работы|work\s*schedule|shift|работ[аы]|job|графік|змін[аи]|program(?:ul)?\s+de\s+lucru|ish\s+grafigi|жұмыс\s+кестесі|жумуш\s+графиги)/iu;
-function scheduleDaysOffMode(text) {
-  if (/(?:плавающ|floating|flexible\s+days\s+off)/iu.test(text)) return 'floating';
-  if (/(?:скользящ|сменн|rotating\s+days\s+off|выходные\s+по\s+графику)/iu.test(text)) return 'rotating';
-  return 'fixed';
-}
-function cycleScheduleValue(work, rest, daysOffMode) {
-  // Day cycles such as 2/2 and 5/2 are common. Values larger than a week in
-  // an explicit schedule context are the conventional shift notation 24/48
-  // or 12/24, not a claim of dozens of working days.
-  if (Math.max(work, rest) > 7) {
-    // An hour cycle has no fixed weekday rest days. Keep an explicitly
-    // floating mode, otherwise expose the inherent repeating rotation.
-    return Object.freeze({ type: 'cycle', cycleHours: Object.freeze({ work, rest }), daysOffMode: daysOffMode === 'fixed' ? 'rotating' : daysOffMode });
-  }
-  return Object.freeze({ type: 'cycle', workDays: work, restDays: rest, daysOffMode });
-}
-function isTimeRangeContextual(match, text) {
-  if (/[.:]|\b(?:am|pm|утра|вечера|ранку|вечора|ertalab|kechqurun)\b/iu.test(match[0])) return true;
-  if (/^\s*(?:с|from)\b/iu.test(match[0])) return true;
-  const start = match.index ?? 0;
-  return SCHEDULE_CONTEXT_RE.test(text.slice(Math.max(0, start - 32), start + match[0].length + 32));
-}
-function isClockContextual(match, text) {
-  if (/(?:am|pm|утра|вечера|ранку|вечора|ertalab|kechqurun)/iu.test(match[0])) return true;
-  const start = match.index ?? 0;
-  return SCHEDULE_CONTEXT_RE.test(text.slice(Math.max(0, start - 24), start + match[0].length + 24));
-}
-function dateAtMonthEnd(year, month) { return dateValue(year, month, new Date(Date.UTC(year, month, 0)).getUTCDate()); }
-function dateAtNextMonthStart(reference) { const month = reference.getUTCMonth() + 2; const year = reference.getUTCFullYear() + Math.floor((month - 1) / 12); return dateValue(year, ((month - 1) % 12) + 1, 1); }
-function nextWeekday(date, weekday) { const current = (date.getUTCDay() + 6) % 7; let days = (weekday - current + 7) % 7; if (days === 0) days = 7; return addUtcDays(date, days); }
+/**
+ * Parser Engine V2's temporal subsystem. Each semantic category — calendar
+ * dates, relative dates, durations, clock/time-ranges, work schedules — has
+ * its own parser module (temporal-calendar-date.js, temporal-relative-
+ * date.js, temporal-duration.js, temporal-clock.js, temporal-schedule.js);
+ * this file only orchestrates them, resolves cross-category conflicts, and
+ * exposes the public parseTemporal()/extractTemporalCandidates() API.
+ * Nothing here returns a bare Date — every result is a typed entity
+ * (calendarDate/duration/workSchedule/timeRange/clockTime/...) with its own
+ * evidence, confidence and span.
+ */
 
 /** Extract generic temporal candidates without silently fabricating a Date. */
 export function extractTemporalCandidates(value, context = {}) {
-  const text = String(value || ''); const candidates = [];
-  for (const match of text.matchAll(new RegExp(DATE_NUMERIC_RE, 'gu'))) {
-    const date = match[1] ? dateValue(Number(match[1]), Number(match[2]), Number(match[3])) : dateValue(Number(match[6]), Number(match[5]), Number(match[4]));
-    if (validDate(date)) candidates.push(candidate(dateEntityType(text, match.index ?? 0, context), date, match, 'temporal.calendar.numeric', .98, [{ type: 'regex', rule: 'numeric-date' }]));
-  }
-  for (const match of text.matchAll(new RegExp(DATE_NUMERIC_PARTIAL_RE, 'gu'))) {
-    const start = match.index ?? 0; const around = text.slice(Math.max(0, start - 40), start + match[0].length + 40);
-    if (!/(?:deadline|apply\s+by|closing\s+date|дедлайн|срок(?:\s+подачи)?|термін(?:\s+подання)?|свобод|доступ|заезд|заезж|available|move[- ]?in|(?<![\p{L}\p{N}])(?:с|до|from|until)(?![\p{L}\p{N}]))/iu.test(around)) continue;
-    const relation = relationNear(text, start); const inferred = true;
-    const date = dateValue(inferYear(Number(match[2]), Number(match[1]), relation, context), Number(match[2]), Number(match[1]));
-    if (validDate(date)) candidates.push(candidate(dateEntityType(text, start, context, relation), date, match, 'temporal.calendar.numeric-partial', .86, [{ type: 'regex', rule: 'numeric-partial-date' }, ...inferredDateEvidence(inferred, context)]));
-  }
-  for (const match of text.matchAll(new RegExp(DATE_WORD_RE, 'giu'))) {
-    const monthIndex = HIRING_MONTHS[match[2].toLocaleLowerCase('ru')]; if (monthIndex == null) continue;
-    const relation = relationNear(text, match.index ?? 0); const inferred = !match[3]; const date = dateValue(inferred ? inferYear(monthIndex + 1, Number(match[1]), relation, context) : Number(match[3]), monthIndex + 1, Number(match[1]));
-    if (validDate(date)) candidates.push(candidate(dateEntityType(text, match.index ?? 0, context, relation), date, match, 'temporal.calendar.month-name', inferred ? .88 : .96, [{ type: 'dictionary', dictionary: 'months', key: match[2] }, ...inferredDateEvidence(inferred, context)]));
-  }
-  for (const match of text.matchAll(new RegExp(DATE_MONTH_FIRST_RE, 'giu'))) {
-    const monthIndex = HIRING_MONTHS[match[1].toLocaleLowerCase('ru')]; if (monthIndex == null) continue;
-    const relation = relationNear(text, match.index ?? 0); const inferred = !match[3]; const date = dateValue(inferred ? inferYear(monthIndex + 1, Number(match[2]), relation, context) : Number(match[3]), monthIndex + 1, Number(match[2]));
-    if (validDate(date)) candidates.push(candidate(dateEntityType(text, match.index ?? 0, context, relation), date, match, 'temporal.calendar.month-first', inferred ? .88 : .96, [{ type: 'dictionary', dictionary: 'months', key: match[1] }, ...inferredDateEvidence(inferred, context)]));
-  }
-  for (const match of text.matchAll(END_OF_MONTH_RE)) {
-    const monthIndex = HIRING_MONTHS[match[1].toLocaleLowerCase('ru')]; if (monthIndex == null) continue;
-    const inferred = !match[2]; const year = inferred ? inferYear(monthIndex + 1, 1, 'until', context) : Number(match[2]);
-    candidates.push(candidate('availabilityUntil', dateAtMonthEnd(year, monthIndex + 1), match, 'temporal.calendar.month-end', inferred ? .86 : .94, [{ type: 'dictionary', dictionary: 'months', key: match[1] }, { type: 'relation', value: 'until-month-end' }, ...inferredDateEvidence(inferred, context)]));
-  }
-  for (const match of text.matchAll(START_OF_MONTH_RE)) {
-    const reference = referenceDate(context); const date = dateValue(reference.getUTCFullYear(), reference.getUTCMonth() + 1, 1);
-    candidates.push(candidate(temporalContextType(text, match.index ?? 0, context), date, match, 'temporal.relative.month-start', .88, [{ type: 'context', value: 'month-start' }, { type: 'reference-date', value: referenceEntry(context).source }]));
-  }
-  for (const match of text.matchAll(NEXT_MONTH_RE)) {
-    const date = dateAtNextMonthStart(referenceDate(context));
-    candidates.push(candidate(temporalContextType(text, match.index ?? 0, context), date, match, 'temporal.relative.next-month', .88, [{ type: 'context', value: 'next-month' }, { type: 'reference-date', value: referenceEntry(context).source }]));
-  }
-  for (const match of text.matchAll(NEXT_WEEKDAY_RE)) {
-    const weekday = DAY_ALIASES[match[1].toLowerCase()]; if (weekday == null) continue;
-    candidates.push(candidate(temporalContextType(text, match.index ?? 0, context), nextWeekday(referenceDate(context), weekday), match, 'temporal.relative.next-weekday', .9, [{ type: 'dictionary', dictionary: 'weekdays', key: match[1] }, { type: 'reference-date', value: referenceEntry(context).source }]));
-  }
-  for (const match of text.matchAll(RELATIVE_RE)) { const days = relativeDays(match[1]); if (days == null) continue; const type = temporalContextType(text, match.index ?? 0, context); candidates.push(candidate(type, addUtcDays(referenceDate(context), days), match, 'temporal.relative-date', .91, [{ type: 'context', value: `relative:${days}d` }, { type: 'reference-date', value: referenceEntry(context).source }])); }
-  for (const match of text.matchAll(EXTENDED_RELATIVE_RE)) {
-    const amount = match[1] || match[3] || match[5];
-    const unit = match[2] || match[4] || match[6];
-    const days = relativeDurationDays(amount, unit);
-    if (days == null) continue;
-    const type = temporalContextType(text, match.index ?? 0, context);
-    candidates.push(candidate(type, addUtcDays(referenceDate(context), days), match, 'temporal.relative-date.extended', .91, [{ type: 'context', value: `relative:${days}d` }, { type: 'unit', value: unit }, { type: 'reference-date', value: referenceEntry(context).source }]));
-  }
-  for (const match of text.matchAll(new RegExp(DURATION_NUMBER_FIRST_RE, 'giu'))) { const value = durationValue(match[1], match[2], match[3]); candidates.push(candidate(semanticDurationType(text, match.index ?? 0, value), value, match, 'temporal.duration.number-unit', .95, [{ type: 'unit', value: match[3] }, ...(match[1] ? [{ type: 'prefix', value: match[1] }] : [])])); }
-  for (const match of text.matchAll(new RegExp(DURATION_RE, 'giu'))) {
-    if (match[3]) continue;
-    // Bare genitive "дня" is almost always part of another phrase ("конца
-    // дня", "сегодняшнего дня", "через 2 дня") rather than a standalone
-    // 1-day duration. Only accept it here when an explicit duration prefix
-    // ("на", "минимум", ...) makes the duration reading unambiguous.
-    if (!match[1] && /^дня$/iu.test(match[2])) continue;
-    const value = durationValue(match[1], match[3], match[2]); candidates.push(candidate(semanticDurationType(text, match.index ?? 0, value), value, match, 'temporal.duration.word-unit', .94, [{ type: 'unit', value: match[2] }, ...(match[1] ? [{ type: 'prefix', value: match[1] }] : [])]));
-  }
-  const timeRangeSpans = [];
-  for (const match of text.matchAll(new RegExp(TIME_RANGE_RE, 'giu'))) {
-    const start = parseClock(match[1]); const end = parseClock(match[2]);
-    if (!start || !end || !isTimeRangeContextual(match, text)) continue;
-    timeRangeSpans.push([match.index ?? 0, (match.index ?? 0) + match[0].length]);
-    candidates.push(candidate('timeRange', Object.freeze({ start, end, crossesMidnight: start.hour * 60 + start.minute > end.hour * 60 + end.minute }), match, 'temporal.time-range', .98, [{ type: 'range', value: 'clock-time' }]));
-  }
-  for (const match of text.matchAll(new RegExp(TIME_RE, 'giu'))) {
-    const start = match.index ?? 0; const end = start + match[0].length;
-    if (timeRangeSpans.some(([rangeStart, rangeEnd]) => start >= rangeStart && end <= rangeEnd) || !isClockContextual(match, text)) continue;
-    const clock = parseClock(match[0]); if (clock) candidates.push(candidate('clockTime', clock, match, 'temporal.clock-time', .94, [{ type: 'clock', value: 'explicit' }]));
-  }
-  const scheduleContext = SCHEDULE_CONTEXT_RE;
-  for (const match of text.matchAll(/(?<![\d:.])(\d{1,2})\s*(?:\/|\\|через|-)\s*(\d{1,2})(?![\d:.])/giu)) {
-    const around = text.slice(Math.max(0, (match.index ?? 0) - 32), (match.index ?? 0) + match[0].length + 32); if (!scheduleContext.test(around)) continue;
-    const daysOffMode = scheduleDaysOffMode(around);
-    const work = Number(match[1]); const rest = Number(match[2]);
-    candidates.push(candidate('workSchedule', cycleScheduleValue(work, rest, daysOffMode), match, 'temporal.schedule-cycle', .99, [{ type: 'context', value: 'schedule' }, { type: 'range', value: Math.max(work, rest) > 7 ? 'cycle-hours' : 'cycle' }, { type: 'days-off-mode', value: daysOffMode }]));
-  }
-  for (const match of text.matchAll(/(?<![\p{L}\p{N}])два\s+через\s+два(?![\p{L}\p{N}])/giu)) {
-    const around = text.slice(Math.max(0, (match.index ?? 0) - 32), (match.index ?? 0) + match[0].length + 32); if (!scheduleContext.test(around)) continue;
-    const daysOffMode = scheduleDaysOffMode(around);
-    candidates.push(candidate('workSchedule', Object.freeze({ type: 'cycle', workDays: 2, restDays: 2, daysOffMode }), match, 'temporal.schedule-cycle.words', .97, [{ type: 'context', value: 'schedule' }, { type: 'range', value: 'cycle' }, { type: 'days-off-mode', value: daysOffMode }]));
-  }
-  for (const match of text.matchAll(WEEKDAY_RANGE_RE)) {
-    const start = DAY_ALIASES[match[1].toLowerCase()]; const end = DAY_ALIASES[match[2].toLowerCase()];
-    if (start == null || end == null || end < start) continue;
-    candidates.push(candidate('workSchedule', Object.freeze({ type: 'weekdays', workingDays: WEEKDAYS.slice(start, end + 1), daysOffMode: 'fixed' }), match, 'temporal.schedule-weekdays', .97, [{ type: 'range', value: 'weekday' }]));
-  }
-  for (const match of text.matchAll(/(?<![\p{L}\p{N}])(?:по\s+будням|weekdays?)(?![\p{L}\p{N}])/giu)) {
-    candidates.push(candidate('workSchedule', Object.freeze({ type: 'weekdays', workingDays: WEEKDAYS.slice(0, 5), daysOffMode: 'fixed' }), match, 'temporal.schedule-weekdays.named', .96, [{ type: 'context', value: 'weekdays' }]));
-  }
-  for (const match of text.matchAll(/(?<![\p{L}\p{N}])(?:только\s+по\s+выходным|weekends?\s+only)(?![\p{L}\p{N}])/giu)) {
-    candidates.push(candidate('workSchedule', Object.freeze({ type: 'weekdays', workingDays: WEEKDAYS.slice(5), daysOffMode: 'fixed' }), match, 'temporal.schedule-weekends', .96, [{ type: 'context', value: 'weekends' }]));
-  }
-  const shifts = [];
-  let firstShift = null; let lastShift = null;
-  for (const match of text.matchAll(SHIFT_RE)) { const start = parseClock(match[2]); const end = parseClock(match[3]); if (!start || !end) continue; firstShift ||= match; lastShift = match; shifts.push(Object.freeze({ name: `${match[1]} shift`, hours: Object.freeze({ start, end, crossesMidnight: start.hour * 60 + start.minute > end.hour * 60 + end.minute }) })); }
-  if (shifts.length) candidates.push(candidate('shifts', Object.freeze(shifts), { 0: text.slice(firstShift.index, (lastShift.index ?? 0) + lastShift[0].length), index: firstShift.index }, 'temporal.multiple-shifts', .98, [{ type: 'context', value: 'shift' }, { type: 'range', value: 'clock-time' }]));
-  return Object.freeze(candidates);
+  const text = String(value || '');
+  return Object.freeze([
+    ...extractCalendarDateCandidates(text, context),
+    ...extractRelativeDateCandidates(text, context),
+    ...extractDurationCandidates(text),
+    ...extractClockCandidates(text),
+    ...extractScheduleCandidates(text, parseClock),
+  ]);
 }
 
 // The default resolver only rejects overlapping candidates of the *same*