@heripo/research-radar 6.0.2 → 6.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -70,7 +70,7 @@ For academic publications:
70
70
  npm install @heripo/research-radar '@llm-newsletter-kit/core@~3.1.1'
71
71
  ```
72
72
 
73
- **Requirements**: Node.js 24.15.0 or newer within 24.x, or >= 26.0.0, and an ESM application. Node.js 25 is not supported. The package exports `dist/index.js` and TypeScript declarations (`dist/index.d.ts`), with a JavaScript sourcemap. The core engine is a peer dependency; the current supported range is `~3.1.1`. Core 3.1.1 is required for recent-title guarding and source-grounded deadline extraction. It also includes the crawl-timeout retry handling and generation self-verification retry cap required by Radar.
73
+ **Requirements**: Node.js 24.22.1 or newer within 24.x, or >= 26.12.1, and an ESM application. Node.js 25 is not supported. The package exports `dist/index.js` and TypeScript declarations (`dist/index.d.ts`), with a JavaScript sourcemap. The core engine is a peer dependency; the current supported range is `~3.1.1`. Core 3.1.1 is required for recent-title guarding and source-grounded deadline extraction. It also includes the crawl-timeout retry handling and generation self-verification retry cap required by Radar.
74
74
 
75
75
  An OpenAI API key is always required and supplies all default models. The optional compatibility path for Anthropic or Google newsletter generation additionally requires that provider's key. Keys are passed explicitly to the library; load environment variables in your application.
76
76
 
@@ -212,21 +212,30 @@ deadlines }` from a successful refresh skips extraction only if a fresh fetch
212
212
 
213
213
  Pass host-selected verified actions to
214
214
  `renderVerifiedDeadlineReminders(reminders, publicationDate)` and place its result
215
- in `templateOptions.deadlineRemindersMarkdown`. Today's and upcoming active
216
- deadlines/events within seven days take priority; ongoing events through a known
217
- end date fill any remaining slots. Each group is ordered by date and time, with
218
- at most five entries overall. It preserves supplied periods and times
215
+ in `templateOptions.deadlineRemindersMarkdown`. Active deadlines/events from
216
+ D-3 through today take priority; ongoing events through a known end date fill
217
+ any remaining slots. Each group is ordered by date and time, with at most ten
218
+ entries overall (`DEADLINE_REMINDER_LEAD_DAYS`, `DEADLINE_REMINDER_LIMIT`). It preserves supplied periods and times
219
219
  without inventing 23:59. The heading is **다가오는 일정·마감**. Today's entries say
220
220
  **오늘 마감**, **오늘 개최** or **오늘 공개**, while ongoing events say **진행 중**.
221
221
  An event's start time is not a cutoff: only its stated end time expires it during
222
222
  the end date. Without an end date, it is listed only through its start date. The provider appends it to saved Markdown and HTML after
223
- generation, so reminders add no LLM context. The host owns D-7/D-1 scheduling,
224
- repeat suppression and publication history. Empty sections are omitted.
223
+ generation, so reminders add no article-generation context. The host owns
224
+ reminder scheduling, repeat suppression and publication history. Empty sections are omitted.
225
225
 
226
226
  Prefer `templateOptions.verifiedDeadlineReminders` with freshly verified historical
227
227
  actions. The provider merges these with source-grounded deadlines from articles
228
- actually linked in the generated body, sorts them, and displays at most five
229
- eligible deadlines/events in one linked section. Deduplication includes the
228
+ actually linked in the generated body and displays at most ten eligible
229
+ deadlines/events in one linked section. `generateNewsletter()` asks the
230
+ importance model to choose those rows from every eligible entry: it answers with
231
+ candidate indices only, favours actions readers can take, keeps D-1 to D-3
232
+ alongside today's entries and drops the same event announced by several
233
+ sources. Titles, dates and links are always rendered from the verified rows,
234
+ and an error, a 60-second timeout or an unusable answer falls back to the first
235
+ ten by date. A short selection is filled in date order, skipping the rows the
236
+ model named as duplicates. Set
237
+ `recentReminderCount` on a reminder to tell the selection how many issues in
238
+ the past week already listed it. Deduplication includes the
230
239
  entry type, so a registration cutoff cannot replace an attendance schedule.
231
240
  Event identity also includes the start/end dates and times, preserving separate
232
241
  occurrences with the same title and kind. Deadline action deduplication is unchanged.
@@ -418,7 +427,7 @@ npm run format # format src/ with Prettier
418
427
  npm run format:check # check src/ formatting
419
428
  ```
420
429
 
421
- The build emits ESM, declarations, and a JavaScript sourcemap; runtime dependencies remain external. CI runs `npm ci`, `format:check`, `lint:ci`, `typecheck`, `npm test`, and `build` on the minimum supported Node.js version (24.15.0), the latest 24.x, and the latest 26.x for pull requests and manual dispatch. Formatting scripts cover `src/`; to check the READMEs explicitly, run `npx prettier --check README.md README-ko.md`. `npm test` uses Node's experimental module mocking and the installed AI SDK test utilities; it makes no LLM, crawling, or email requests.
430
+ The build emits ESM, declarations, and a JavaScript sourcemap; runtime dependencies remain external. CI runs `npm ci`, `format:check`, `lint:ci`, `typecheck`, `npm test`, and `build` on the minimum supported versions for Node.js 24 and 26 (24.22.1 and 26.12.1), the latest 24.x, and the latest 26.x for pull requests and manual dispatch. Formatting scripts cover `src/`; to check the READMEs explicitly, run `npx prettier --check README.md README-ko.md`. `npm test` uses Node's experimental module mocking and the installed AI SDK test utilities; it makes no LLM, crawling, or email requests.
422
431
 
423
432
  For maintainers, `release` publishes to npm, while `release:patch`, `release:minor`, and `release:major` bump the version and publish. The version hooks build first and push commits/tags; `prepublishOnly` builds before publishing.
424
433
 
package/dist/index.d.ts CHANGED
@@ -7,8 +7,24 @@ interface VerifiedDeadlineReminder {
7
7
  deadline: ArticleDeadline;
8
8
  url: UrlString;
9
9
  verificationStatus: 'verified';
10
+ /**
11
+ * Published issues in the past week that already listed this action.
12
+ * Host-supplied history; it only informs the reminder selection prompt.
13
+ */
14
+ recentReminderCount?: number;
15
+ }
16
+ /** Days before the date an action first becomes eligible (D-3 through D-day). */
17
+ declare const DEADLINE_REMINDER_LEAD_DAYS = 3;
18
+ /** Rows the unified deadline section displays. */
19
+ declare const DEADLINE_REMINDER_LIMIT = 10;
20
+ /** A reminder that passed every display guard, with its normalized link. */
21
+ interface EligibleDeadlineReminder {
22
+ reminder: VerifiedDeadlineReminder;
23
+ /** Calendar days from publication to the start date; negative while ongoing. */
24
+ days: number;
25
+ url: string;
10
26
  }
11
- /** Deterministic deadlines/events, no LLM context. Host owns selection and history. */
27
+ /** Deterministic deadlines/events, no LLM context: the first rows by date. */
12
28
  declare function renderVerifiedDeadlineReminders(reminders: VerifiedDeadlineReminder[], publicationDate: IsoDateString, now?: Date): string;
13
29
 
14
30
  /**
@@ -512,6 +528,46 @@ declare class AnalysisProvider implements AnalysisProvider$1 {
512
528
  update(article: ArticleForUpdateByAnalysis): Promise<void>;
513
529
  }
514
530
 
531
+ /**
532
+ * Chooses which eligible reminders the unified section displays.
533
+ *
534
+ * Returns a subset of the given rows in their original display order.
535
+ */
536
+ type DeadlineReminderSelector = (rows: EligibleDeadlineReminder[], publicationDate: IsoDateString) => Promise<EligibleDeadlineReminder[]>;
537
+ type DeadlineReminderSelectorOptions = {
538
+ /** Same model that scores article importance. */
539
+ model: LanguageModel;
540
+ /**
541
+ * Milliseconds before the selection gives up and falls back. It runs while
542
+ * saving a fully generated issue, so a stalled provider must not hold it.
543
+ * @default 60000
544
+ */
545
+ timeoutMs?: number;
546
+ /** Reports a selection that fell back to the first rows by date. */
547
+ onFallback?: (reason: string, candidateCount: number) => void;
548
+ /** Reports a model selection and its token usage. */
549
+ onSelected?: (info: {
550
+ candidateCount: number;
551
+ selectedCount: number;
552
+ /** Rows added by date order because the model chose too few. */
553
+ filledCount: number;
554
+ usage: unknown;
555
+ }) => void;
556
+ };
557
+ /**
558
+ * Builds the model selection that replaces "first rows by date".
559
+ *
560
+ * Several sources often announce the same 학술대회, and a busy day can hold
561
+ * fifteen same-day bids, so the earliest rows are a poor proxy for what readers
562
+ * need. The model judges relevance and duplicates; everything that decides
563
+ * whether a row may appear at all stays in {@link eligibleDeadlineReminders}.
564
+ *
565
+ * It never fails the newsletter: an error, a timeout, an empty answer or
566
+ * unusable indices fall back to the first rows by date. A selection shorter
567
+ * than the rows available is filled in date order, skipping named duplicates.
568
+ */
569
+ declare const createDeadlineReminderSelector: (options: DeadlineReminderSelectorOptions) => DeadlineReminderSelector;
570
+
515
571
  /**
516
572
  * Content generation provider implementation
517
573
  * - LLM-based newsletter content generation
@@ -522,6 +578,8 @@ declare class ContentGenerateProvider implements ContentGenerateProvider$1 {
522
578
  private readonly articleRepository;
523
579
  private readonly newsletterRepository;
524
580
  private readonly templateOptions?;
581
+ /** Chooses displayed reminders; omitted, the first rows by date display. */
582
+ private readonly selectDeadlineReminders?;
525
583
  private _issueOrder;
526
584
  private readonly deadlineRemindersMarkdown;
527
585
  readonly model: LanguageModel;
@@ -530,7 +588,9 @@ declare class ContentGenerateProvider implements ContentGenerateProvider$1 {
530
588
  htmlTemplate: HtmlTemplate;
531
589
  /** Newsletter brand name (defaults to config, can be overridden via constructor) */
532
590
  newsletterBrandName: string;
533
- constructor(model: LanguageModel, articleRepository: ArticleRepository, newsletterRepository: NewsletterRepository, templateOptions?: NewsletterTemplateOptions | undefined, brandName?: string);
591
+ constructor(model: LanguageModel, articleRepository: ArticleRepository, newsletterRepository: NewsletterRepository, templateOptions?: NewsletterTemplateOptions | undefined, brandName?: string,
592
+ /** Chooses displayed reminders; omitted, the first rows by date display. */
593
+ selectDeadlineReminders?: DeadlineReminderSelector | undefined);
534
594
  /** LLM temperature setting for content generation */
535
595
  temperature: number;
536
596
  /** Subscribe page URL */
@@ -565,6 +625,7 @@ declare class ContentGenerateProvider implements ContentGenerateProvider$1 {
565
625
  }): Promise<{
566
626
  id: string | number;
567
627
  }>;
628
+ private renderDeadlineReminders;
568
629
  }
569
630
 
570
631
  type HeritageBidCandidate = {
@@ -793,5 +854,5 @@ declare function fetchResearchRadarDeadlineSource({ source, customFetch, publicD
793
854
  /** Only explicit, grounded results are verified. Missing dates are never cancellation. */
794
855
  declare function refreshResearchRadarDeadlines(config: ResearchRadarDeadlineRefreshConfig): Promise<ResearchRadarDeadlineRefreshResult>;
795
856
 
796
- export { AnalysisProvider, ContentGenerateProvider, CrawlingProvider, DateService, TaskService, contentOptions, createCrawlingTargetGroups, extractResearchRadarDeadlines, fetchResearchRadarDeadlineSource, generateNewsletter, generateWelcomeHTML, getSourceList, llmConfig, maximumImportanceScoreByDomain, newsletterConfig, refreshResearchRadarDeadlines, renderVerifiedDeadlineReminders, researchRadarPromptProvider, robotsExemptOrigins };
797
- export type { ArticleRepository, ContentGenerationConfig, ContentOptions, DeadlineVerificationFailure, ExcavationReport, ExcavationReportSource, NewsletterConfig, NewsletterGeneratorDependencies, NewsletterModelConfig, NewsletterRepository, NewsletterTemplateOptions, PreviewNewsletterOptions, ResearchRadarDeadlineExtractionConfig, ResearchRadarDeadlineRefreshConfig, ResearchRadarDeadlineRefreshResult, ResearchRadarDeadlineSource, ResearchRadarDeadlineSourceOptions, ResearchRadarDeadlineSourceResult, SourceGroup, SourceItem, TagRepository, TaskRepository, VerifiedDeadlineReminder, WelcomeTemplateOptions };
857
+ export { AnalysisProvider, ContentGenerateProvider, CrawlingProvider, DEADLINE_REMINDER_LEAD_DAYS, DEADLINE_REMINDER_LIMIT, DateService, TaskService, contentOptions, createCrawlingTargetGroups, createDeadlineReminderSelector, extractResearchRadarDeadlines, fetchResearchRadarDeadlineSource, generateNewsletter, generateWelcomeHTML, getSourceList, llmConfig, maximumImportanceScoreByDomain, newsletterConfig, refreshResearchRadarDeadlines, renderVerifiedDeadlineReminders, researchRadarPromptProvider, robotsExemptOrigins };
858
+ export type { ArticleRepository, ContentGenerationConfig, ContentOptions, DeadlineReminderSelector, DeadlineReminderSelectorOptions, DeadlineVerificationFailure, EligibleDeadlineReminder, ExcavationReport, ExcavationReportSource, NewsletterConfig, NewsletterGeneratorDependencies, NewsletterModelConfig, NewsletterRepository, NewsletterTemplateOptions, PreviewNewsletterOptions, ResearchRadarDeadlineExtractionConfig, ResearchRadarDeadlineRefreshConfig, ResearchRadarDeadlineRefreshResult, ResearchRadarDeadlineSource, ResearchRadarDeadlineSourceOptions, ResearchRadarDeadlineSourceResult, SourceGroup, SourceItem, TagRepository, TaskRepository, VerifiedDeadlineReminder, WelcomeTemplateOptions };
package/dist/index.js CHANGED
@@ -200,7 +200,7 @@ function identityOf(candidate) {
200
200
  candidate.classification?.trim() ?? '',
201
201
  ];
202
202
  }
203
- function buildUserPrompt(candidates) {
203
+ function buildUserPrompt$1(candidates) {
204
204
  const lines = candidates.map((candidate, index) => {
205
205
  const [institution, title, classification] = identityOf(candidate);
206
206
  return (`${index}. [${institution}] ${title}` +
@@ -218,7 +218,7 @@ async function triageBatch(candidates, { model, onFallback }, signal) {
218
218
  model,
219
219
  output: Output.object({ schema: KEEP_SCHEMA }),
220
220
  system: SYSTEM_PROMPT,
221
- prompt: buildUserPrompt(candidates),
221
+ prompt: buildUserPrompt$1(candidates),
222
222
  abortSignal: signal,
223
223
  });
224
224
  const verdicts = new Array(candidates.length).fill(false);
@@ -301,6 +301,402 @@ const createHeritageBidTriage = (options) => {
301
301
  };
302
302
  };
303
303
 
304
+ /**
305
+ * Date service implementation
306
+ * - Provides newsletter publication date strings (ISO and localized display form)
307
+ * - Always returns Korea Standard Time (KST, Asia/Seoul) regardless of server timezone
308
+ * - Accepts optional publishDate to override "today" (e.g., generating today's run for tomorrow's publication)
309
+ */
310
+ class DateService {
311
+ targetDate;
312
+ /**
313
+ * @param publishDate - Optional ISO date string (YYYY-MM-DD) representing the newsletter
314
+ * publication date. If omitted, the current wall-clock time (KST)
315
+ * is used. Pass tomorrow's date when building the issue the night before.
316
+ * @throws {Error} If publishDate is not in YYYY-MM-DD format or is not a real calendar date.
317
+ */
318
+ constructor(publishDate) {
319
+ if (publishDate !== undefined) {
320
+ if (!/^\d{4}-\d{2}-\d{2}$/.test(publishDate)) {
321
+ throw new Error(`Invalid publishDate format: "${publishDate}". Expected YYYY-MM-DD (e.g., "2025-02-12").`);
322
+ }
323
+ const date = new Date(publishDate + 'T00:00:00+09:00');
324
+ // Round-trip check: format back to YYYY-MM-DD in KST and compare.
325
+ // Catches invalid dates like "2025-02-30" that JS silently normalizes to "2025-03-02".
326
+ const roundTrip = date.toLocaleDateString('en-CA', {
327
+ timeZone: 'Asia/Seoul',
328
+ });
329
+ if (roundTrip !== publishDate) {
330
+ throw new Error(`Invalid publishDate: "${publishDate}" is not a real calendar date.`);
331
+ }
332
+ this.targetDate = date;
333
+ }
334
+ else {
335
+ this.targetDate = new Date();
336
+ }
337
+ }
338
+ /**
339
+ * Get the newsletter publication date in ISO format (YYYY-MM-DD).
340
+ * - Always returns date in Korea Standard Time (UTC+9)
341
+ * @returns ISO date string (e.g., "2024-10-15")
342
+ */
343
+ getPublicationISODateString() {
344
+ // Use Intl.DateTimeFormat to get date in Korea timezone
345
+ // 'en-CA' locale returns YYYY-MM-DD format by default
346
+ const kstDate = this.targetDate.toLocaleDateString('en-CA', {
347
+ timeZone: 'Asia/Seoul',
348
+ });
349
+ return kstDate;
350
+ }
351
+ getCurrentISODateString() {
352
+ return this.getPublicationISODateString();
353
+ }
354
+ /**
355
+ * Get the newsletter publication date as a localized display string.
356
+ * - Always returns date in Korea Standard Time (UTC+9)
357
+ * @returns Korean formatted date (e.g., "2024년 10월 15일")
358
+ */
359
+ getPublicationDisplayDateString() {
360
+ const formatter = new Intl.DateTimeFormat('ko-KR', {
361
+ timeZone: 'Asia/Seoul',
362
+ year: 'numeric',
363
+ month: 'long',
364
+ day: 'numeric',
365
+ });
366
+ return formatter.format(this.targetDate);
367
+ }
368
+ getDisplayDateString() {
369
+ return this.getPublicationDisplayDateString();
370
+ }
371
+ }
372
+
373
+ /** Days before the date an action first becomes eligible (D-3 through D-day). */
374
+ const DEADLINE_REMINDER_LEAD_DAYS = 3;
375
+ /** Rows the unified deadline section displays. */
376
+ const DEADLINE_REMINDER_LIMIT = 10;
377
+ function escapeLabel(value) {
378
+ return value
379
+ .replace(/\s+/g, ' ')
380
+ .replace(/&/g, '&amp;')
381
+ .replace(/</g, '&lt;')
382
+ .replace(/>/g, '&gt;')
383
+ .replace(/[\\`*_{}[\]()|!#]/g, '\\$&');
384
+ }
385
+ const clockPattern = /^(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d)?$/;
386
+ const fullClock = (time) => (time.length === 5 ? `${time}:00` : time);
387
+ function calendarMs(date) {
388
+ if (!/^\d{4}-\d{2}-\d{2}$/.test(date))
389
+ return NaN;
390
+ const ms = Date.parse(`${date}T00:00:00Z`);
391
+ return Number.isFinite(ms) && new Date(ms).toISOString().slice(0, 10) === date
392
+ ? ms
393
+ : NaN;
394
+ }
395
+ /**
396
+ * Every displayable reminder, deduplicated and in display order.
397
+ *
398
+ * Eligibility stays deterministic: only verified, active actions from D-3
399
+ * through D-day, or events still running, with a safe link and a closing time
400
+ * that has not passed. Selection may choose among these but never adds to them.
401
+ */
402
+ function eligibleDeadlineReminders(reminders, publicationDate, now = new Date()) {
403
+ const date = new DateService(publicationDate).getPublicationISODateString();
404
+ const publicationMs = Date.parse(`${date}T00:00:00Z`);
405
+ const rows = reminders
406
+ .flatMap((reminder) => {
407
+ const { deadline } = reminder;
408
+ if (reminder.verificationStatus !== 'verified' ||
409
+ deadline.status !== 'active' ||
410
+ !deadline.date ||
411
+ !/^\d{4}-\d{2}-\d{2}$/.test(deadline.date))
412
+ return [];
413
+ const isEvent = deadline.type === 'event';
414
+ const ms = calendarMs(deadline.date);
415
+ const endDate = isEvent
416
+ ? (deadline.endDate ?? deadline.date)
417
+ : deadline.date;
418
+ const endMs = calendarMs(endDate);
419
+ if (!Number.isFinite(ms) || !Number.isFinite(endMs) || endMs < ms)
420
+ return [];
421
+ if ((!isEvent && (deadline.endDate || deadline.endTime)) ||
422
+ (deadline.endTime && !deadline.endDate))
423
+ return [];
424
+ if ((deadline.time && !clockPattern.test(deadline.time)) ||
425
+ (deadline.endTime && !clockPattern.test(deadline.endTime)))
426
+ return [];
427
+ if (isEvent &&
428
+ endDate === deadline.date &&
429
+ deadline.time &&
430
+ deadline.endTime &&
431
+ fullClock(deadline.endTime) < fullClock(deadline.time))
432
+ return [];
433
+ const days = (ms - publicationMs) / 86_400_000;
434
+ // Events remain eligible through a known end date; a start time is never
435
+ // treated as an application cutoff. Unknown endpoints stay unknown.
436
+ if (days > DEADLINE_REMINDER_LEAD_DAYS ||
437
+ endMs < publicationMs ||
438
+ !deadline.title.trim())
439
+ return [];
440
+ let url;
441
+ try {
442
+ url = new URL(reminder.url);
443
+ if (!['http:', 'https:'].includes(url.protocol) ||
444
+ url.username ||
445
+ url.password)
446
+ return [];
447
+ if (deadline.timeZone)
448
+ new Intl.DateTimeFormat('en', { timeZone: deadline.timeZone });
449
+ const closingTime = isEvent ? deadline.endTime : deadline.time;
450
+ if (closingTime) {
451
+ const parts = new Intl.DateTimeFormat('en', {
452
+ timeZone: deadline.timeZone ?? 'Asia/Seoul',
453
+ year: 'numeric',
454
+ month: '2-digit',
455
+ day: '2-digit',
456
+ hour: '2-digit',
457
+ minute: '2-digit',
458
+ second: '2-digit',
459
+ hourCycle: 'h23',
460
+ }).formatToParts(now);
461
+ const values = Object.fromEntries(parts.map(({ type, value }) => [type, value]));
462
+ const localNow = `${values.year}-${values.month}-${values.day} ${values.hour}:${values.minute}:${values.second}`;
463
+ const closes = `${endDate} ${fullClock(closingTime)}`;
464
+ if (closes <= localNow)
465
+ return [];
466
+ }
467
+ }
468
+ catch {
469
+ return [];
470
+ }
471
+ return [
472
+ {
473
+ reminder,
474
+ days,
475
+ ms,
476
+ url: url.href.replace(/[()]/g, (value) => encodeURIComponent(value)),
477
+ },
478
+ ];
479
+ })
480
+ .sort((a, b) =>
481
+ // The fallback limit must not let older ongoing events displace
482
+ // today's or upcoming deadlines/events. Ongoing events fill spare rows.
483
+ Number(a.days < 0) - Number(b.days < 0) ||
484
+ a.ms - b.ms ||
485
+ (a.reminder.deadline.time ?? '23:59:59').localeCompare(b.reminder.deadline.time ?? '23:59:59'));
486
+ const seen = new Set();
487
+ return rows.flatMap(({ reminder, days, url }) => {
488
+ const d = reminder.deadline;
489
+ const key = JSON.stringify([
490
+ url,
491
+ d.type ?? 'deadline',
492
+ d.title,
493
+ d.kind,
494
+ d.date,
495
+ d.time,
496
+ d.endDate ?? null,
497
+ d.endTime ?? null,
498
+ ]);
499
+ if (seen.has(key))
500
+ return [];
501
+ seen.add(key);
502
+ return [{ reminder, days, url }];
503
+ });
504
+ }
505
+ /** Renders already eligible rows in the order given, up to the display limit. */
506
+ function formatDeadlineReminders(rows) {
507
+ const lines = rows
508
+ .slice(0, DEADLINE_REMINDER_LIMIT)
509
+ .map(({ reminder, days, url }) => {
510
+ const d = reminder.deadline;
511
+ const isEvent = d.type === 'event';
512
+ const time = d.time ? ` ${d.time}` : '';
513
+ const end = isEvent && d.endDate
514
+ ? d.endDate !== d.date
515
+ ? ` ~ ${d.endDate}${d.endTime ? ` ${d.endTime}` : ''}`
516
+ : d.endTime
517
+ ? ` ~ ${d.endTime}`
518
+ : ''
519
+ : '';
520
+ const zone = (d.time || (isEvent && d.endTime)) && d.timeZone
521
+ ? ` (${escapeLabel(d.timeZone)})`
522
+ : '';
523
+ const timing = days > 0
524
+ ? `D-${days}`
525
+ : days < 0
526
+ ? '진행 중'
527
+ : isEvent
528
+ ? /공개/.test(d.kind)
529
+ ? '오늘 공개'
530
+ : '오늘 개최'
531
+ : '오늘 마감';
532
+ const label = d.title.includes(d.kind)
533
+ ? d.title
534
+ : `${d.title} · ${d.kind}`;
535
+ return `| [${escapeLabel(label)}](${url}) | **${d.date}${time}${end}${zone} · ${timing}** |`;
536
+ });
537
+ return lines.length
538
+ ? `## ⏰ 다가오는 일정·마감\n\n| 안내 | 일정 |\n| --- | --- |\n${lines.join('\n')}`
539
+ : '';
540
+ }
541
+ /** Deterministic deadlines/events, no LLM context: the first rows by date. */
542
+ function renderVerifiedDeadlineReminders(reminders, publicationDate, now = new Date()) {
543
+ return formatDeadlineReminders(eligibleDeadlineReminders(reminders, publicationDate, now));
544
+ }
545
+
546
+ /**
547
+ * Asks for the indices to display, never for titles, dates or links.
548
+ *
549
+ * Rendering stays on the verified rows, so the model can only leave a row out;
550
+ * it cannot invent an action or alter one. Indices out of range or repeated
551
+ * are discarded rather than trusted. Duplicates are named separately so a short
552
+ * selection can be filled without restoring an event the model merged.
553
+ */
554
+ const SELECT_SCHEMA = jsonSchema({
555
+ type: 'object',
556
+ properties: {
557
+ select: {
558
+ type: 'array',
559
+ items: { type: 'integer' },
560
+ description: '뉴스레터에 안내할 일정·마감 후보의 번호',
561
+ },
562
+ duplicates: {
563
+ type: 'array',
564
+ items: { type: 'integer' },
565
+ description: '고른 후보와 같은 행사·마감이라 뺀 후보의 번호',
566
+ },
567
+ },
568
+ required: ['select', 'duplicates'],
569
+ additionalProperties: false,
570
+ });
571
+ const systemPrompt = (limit) => `너는 한국 고고학·문화유산 뉴스레터의 "다가오는 일정·마감" 안내를 고른다.
572
+
573
+ 독자는 고고학·문화유산 연구자, 발굴·조사기관 종사자, 학예 인력, 관련 전공 학생이다.
574
+ 후보는 모두 원문에서 다시 확인한 일정이다. 날짜·제목은 바꿀 수 없고, 너는 번호만 고른다.
575
+
576
+ 고르는 규칙:
577
+ - 최대 ${limit}개를 고른다. 같은 행사 중복을 빼고도 후보가 ${limit}개 이상 남으면 반드시 ${limit}개를 채운다.
578
+ - 같은 행사 중복을 뺀 후보가 ${limit}개 미만이면 중복만 빼고 모두 고른다. 후순위 일정도 자리가 남으면 뺄 이유가 없다.
579
+ - 같은 행사나 같은 마감을 가리키는 후보는 하나만 고르고, 나머지 번호는 duplicates에 넣는다. 게시 기관이 달라 제목 표현이 조금 달라도 날짜·시각과 내용이 같으면 같은 행사다.
580
+ - 시각이 다른 회차, 링크의 공고번호가 다른 공고는 제목이 같아도 서로 다른 일정이다. duplicates에 넣지 않는다.
581
+ - 독자가 행동할 수 있는 일정을 우선한다: 학술대회·발표·논문 신청, 공모·지원사업 신청, 채용 접수, 발굴 현장 공개, 발굴·시굴·지표조사와 국가유산 수리·보존처리 입찰, 강연·답사 참가 신청.
582
+ - 문화유산과 관련이 약한 일반 시설·장비·전산 입찰, 행사 운영 대행은 후순위로 둔다.
583
+ - 오늘 마감·개최는 마지막 기회이므로 중요한 것을 우선 포함한다. 다만 오늘 일정만으로 채우지 말고 D-1~D-3 일정도 고르게 포함해 독자가 미리 준비할 수 있게 한다.
584
+ - "진행 중"인 장기 전시·행사는 남는 자리에만 넣는다. 최근 여러 번 안내된 일정은 더 뒤로 미룬다.
585
+ - 번호의 순서는 상관없다. 표시 순서는 날짜순으로 따로 정해진다.`;
586
+ function timingOf({ days, reminder }) {
587
+ if (days > 0)
588
+ return `D-${days}`;
589
+ if (days < 0)
590
+ return '진행 중';
591
+ return reminder.deadline.type === 'event' ? '오늘 개최' : '오늘 마감';
592
+ }
593
+ function clockOf(date, time) {
594
+ return time ? `${date} ${time}` : date;
595
+ }
596
+ function buildUserPrompt(rows, publicationDate, limit) {
597
+ const lines = rows.map((row, index) => {
598
+ const { deadline, recentReminderCount } = row.reminder;
599
+ const start = clockOf(deadline.date, deadline.time);
600
+ const end = deadline.type === 'event' && deadline.endDate
601
+ ? deadline.endDate !== deadline.date
602
+ ? ` ~ ${clockOf(deadline.endDate, deadline.endTime)}`
603
+ : deadline.endTime
604
+ ? ` ~ ${deadline.endTime}`
605
+ : ''
606
+ : '';
607
+ const zone = deadline.timeZone ? ` (${deadline.timeZone})` : '';
608
+ const recent = recentReminderCount
609
+ ? ` · 최근 7일 ${recentReminderCount}회 안내`
610
+ : '';
611
+ // The full link carries notice numbers, which tell same-titled bids apart.
612
+ return `${index}. [${timingOf(row)}] ${start}${end}${zone} · ${deadline.type === 'event' ? '행사' : '마감'} · ${deadline.kind} · ${deadline.title.replace(/\s+/g, ' ')} · ${row.url}${recent}`;
613
+ });
614
+ return `발행일 ${publicationDate}. 다음 ${rows.length}건 중 안내할 일정을 최대 ${limit}개 골라 번호로 답하라.\n\n${lines.join('\n')}`;
615
+ }
616
+ /**
617
+ * Builds the model selection that replaces "first rows by date".
618
+ *
619
+ * Several sources often announce the same 학술대회, and a busy day can hold
620
+ * fifteen same-day bids, so the earliest rows are a poor proxy for what readers
621
+ * need. The model judges relevance and duplicates; everything that decides
622
+ * whether a row may appear at all stays in {@link eligibleDeadlineReminders}.
623
+ *
624
+ * It never fails the newsletter: an error, a timeout, an empty answer or
625
+ * unusable indices fall back to the first rows by date. A selection shorter
626
+ * than the rows available is filled in date order, skipping named duplicates.
627
+ */
628
+ const createDeadlineReminderSelector = (options) => {
629
+ const limit = DEADLINE_REMINDER_LIMIT;
630
+ const fallback = (rows, reason) => {
631
+ options.onFallback?.(reason, rows.length);
632
+ return rows.slice(0, limit);
633
+ };
634
+ return async (rows, publicationDate) => {
635
+ // One row leaves nothing to choose or deduplicate.
636
+ if (rows.length <= 1)
637
+ return rows;
638
+ const timeoutMs = options.timeoutMs ?? 60_000;
639
+ const controller = new AbortController();
640
+ let timer;
641
+ try {
642
+ // Abort is only a request; a model that ignores it would otherwise hold
643
+ // the save forever, so the race is what bounds the wait.
644
+ const { output, usage } = await Promise.race([
645
+ generateText({
646
+ model: options.model,
647
+ output: Output.object({ schema: SELECT_SCHEMA }),
648
+ system: systemPrompt(limit),
649
+ prompt: buildUserPrompt(rows, publicationDate, limit),
650
+ abortSignal: controller.signal,
651
+ }),
652
+ new Promise((_, reject) => {
653
+ timer = setTimeout(() => {
654
+ controller.abort();
655
+ reject(new Error(`selection timed out after ${timeoutMs}ms`));
656
+ }, timeoutMs);
657
+ }),
658
+ ]);
659
+ const usable = (index) => Number.isInteger(index) && index >= 0 && index < rows.length;
660
+ const chosen = new Set();
661
+ for (const index of output.select) {
662
+ if (chosen.size === limit)
663
+ break;
664
+ if (usable(index))
665
+ chosen.add(index);
666
+ }
667
+ // Every candidate is a verified, current action, so an empty section is
668
+ // a malformed answer rather than a judgement that nothing matters.
669
+ if (!chosen.size)
670
+ return fallback(rows, 'no usable index in the selection');
671
+ const duplicates = new Set((output.duplicates ?? []).filter((index) => usable(index) && !chosen.has(index)));
672
+ // The prompt asks for a full section; a short answer is filled by date
673
+ // rather than trusted, but never with a row the model called a repeat.
674
+ let filledCount = 0;
675
+ for (let index = 0; index < rows.length; index++) {
676
+ if (chosen.size === limit)
677
+ break;
678
+ if (chosen.has(index) || duplicates.has(index))
679
+ continue;
680
+ chosen.add(index);
681
+ filledCount++;
682
+ }
683
+ options.onSelected?.({
684
+ candidateCount: rows.length,
685
+ selectedCount: chosen.size,
686
+ filledCount,
687
+ usage,
688
+ });
689
+ return rows.filter((_, index) => chosen.has(index));
690
+ }
691
+ catch (error) {
692
+ return fallback(rows, error instanceof Error ? error.message : String(error));
693
+ }
694
+ finally {
695
+ clearTimeout(timer);
696
+ }
697
+ };
698
+ };
699
+
304
700
  /**
305
701
  * Reads what data.go.kr said when it refused a request.
306
702
  *
@@ -4679,224 +5075,6 @@ ${poweredByFooterHtml()}
4679
5075
  </body>
4680
5076
  </html>`;
4681
5077
 
4682
- /**
4683
- * Date service implementation
4684
- * - Provides newsletter publication date strings (ISO and localized display form)
4685
- * - Always returns Korea Standard Time (KST, Asia/Seoul) regardless of server timezone
4686
- * - Accepts optional publishDate to override "today" (e.g., generating today's run for tomorrow's publication)
4687
- */
4688
- class DateService {
4689
- targetDate;
4690
- /**
4691
- * @param publishDate - Optional ISO date string (YYYY-MM-DD) representing the newsletter
4692
- * publication date. If omitted, the current wall-clock time (KST)
4693
- * is used. Pass tomorrow's date when building the issue the night before.
4694
- * @throws {Error} If publishDate is not in YYYY-MM-DD format or is not a real calendar date.
4695
- */
4696
- constructor(publishDate) {
4697
- if (publishDate !== undefined) {
4698
- if (!/^\d{4}-\d{2}-\d{2}$/.test(publishDate)) {
4699
- throw new Error(`Invalid publishDate format: "${publishDate}". Expected YYYY-MM-DD (e.g., "2025-02-12").`);
4700
- }
4701
- const date = new Date(publishDate + 'T00:00:00+09:00');
4702
- // Round-trip check: format back to YYYY-MM-DD in KST and compare.
4703
- // Catches invalid dates like "2025-02-30" that JS silently normalizes to "2025-03-02".
4704
- const roundTrip = date.toLocaleDateString('en-CA', {
4705
- timeZone: 'Asia/Seoul',
4706
- });
4707
- if (roundTrip !== publishDate) {
4708
- throw new Error(`Invalid publishDate: "${publishDate}" is not a real calendar date.`);
4709
- }
4710
- this.targetDate = date;
4711
- }
4712
- else {
4713
- this.targetDate = new Date();
4714
- }
4715
- }
4716
- /**
4717
- * Get the newsletter publication date in ISO format (YYYY-MM-DD).
4718
- * - Always returns date in Korea Standard Time (UTC+9)
4719
- * @returns ISO date string (e.g., "2024-10-15")
4720
- */
4721
- getPublicationISODateString() {
4722
- // Use Intl.DateTimeFormat to get date in Korea timezone
4723
- // 'en-CA' locale returns YYYY-MM-DD format by default
4724
- const kstDate = this.targetDate.toLocaleDateString('en-CA', {
4725
- timeZone: 'Asia/Seoul',
4726
- });
4727
- return kstDate;
4728
- }
4729
- getCurrentISODateString() {
4730
- return this.getPublicationISODateString();
4731
- }
4732
- /**
4733
- * Get the newsletter publication date as a localized display string.
4734
- * - Always returns date in Korea Standard Time (UTC+9)
4735
- * @returns Korean formatted date (e.g., "2024년 10월 15일")
4736
- */
4737
- getPublicationDisplayDateString() {
4738
- const formatter = new Intl.DateTimeFormat('ko-KR', {
4739
- timeZone: 'Asia/Seoul',
4740
- year: 'numeric',
4741
- month: 'long',
4742
- day: 'numeric',
4743
- });
4744
- return formatter.format(this.targetDate);
4745
- }
4746
- getDisplayDateString() {
4747
- return this.getPublicationDisplayDateString();
4748
- }
4749
- }
4750
-
4751
- function escapeLabel(value) {
4752
- return value
4753
- .replace(/\s+/g, ' ')
4754
- .replace(/&/g, '&amp;')
4755
- .replace(/</g, '&lt;')
4756
- .replace(/>/g, '&gt;')
4757
- .replace(/[\\`*_{}[\]()|!#]/g, '\\$&');
4758
- }
4759
- const clockPattern = /^(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d)?$/;
4760
- const fullClock = (time) => (time.length === 5 ? `${time}:00` : time);
4761
- function calendarMs(date) {
4762
- if (!/^\d{4}-\d{2}-\d{2}$/.test(date))
4763
- return NaN;
4764
- const ms = Date.parse(`${date}T00:00:00Z`);
4765
- return Number.isFinite(ms) && new Date(ms).toISOString().slice(0, 10) === date
4766
- ? ms
4767
- : NaN;
4768
- }
4769
- /** Deterministic deadlines/events, no LLM context. Host owns selection and history. */
4770
- function renderVerifiedDeadlineReminders(reminders, publicationDate, now = new Date()) {
4771
- const date = new DateService(publicationDate).getPublicationISODateString();
4772
- const publicationMs = Date.parse(`${date}T00:00:00Z`);
4773
- const rows = reminders
4774
- .flatMap((reminder) => {
4775
- const { deadline } = reminder;
4776
- if (reminder.verificationStatus !== 'verified' ||
4777
- deadline.status !== 'active' ||
4778
- !deadline.date ||
4779
- !/^\d{4}-\d{2}-\d{2}$/.test(deadline.date))
4780
- return [];
4781
- const isEvent = deadline.type === 'event';
4782
- const ms = calendarMs(deadline.date);
4783
- const endDate = isEvent
4784
- ? (deadline.endDate ?? deadline.date)
4785
- : deadline.date;
4786
- const endMs = calendarMs(endDate);
4787
- if (!Number.isFinite(ms) || !Number.isFinite(endMs) || endMs < ms)
4788
- return [];
4789
- if ((!isEvent && (deadline.endDate || deadline.endTime)) ||
4790
- (deadline.endTime && !deadline.endDate))
4791
- return [];
4792
- if ((deadline.time && !clockPattern.test(deadline.time)) ||
4793
- (deadline.endTime && !clockPattern.test(deadline.endTime)))
4794
- return [];
4795
- if (isEvent &&
4796
- endDate === deadline.date &&
4797
- deadline.time &&
4798
- deadline.endTime &&
4799
- fullClock(deadline.endTime) < fullClock(deadline.time))
4800
- return [];
4801
- const days = (ms - publicationMs) / 86_400_000;
4802
- // Events remain eligible through a known end date; a start time is never
4803
- // treated as an application cutoff. Unknown endpoints stay unknown.
4804
- if (days > 7 || endMs < publicationMs || !deadline.title.trim())
4805
- return [];
4806
- let url;
4807
- try {
4808
- url = new URL(reminder.url);
4809
- if (!['http:', 'https:'].includes(url.protocol) ||
4810
- url.username ||
4811
- url.password)
4812
- return [];
4813
- if (deadline.timeZone)
4814
- new Intl.DateTimeFormat('en', { timeZone: deadline.timeZone });
4815
- const closingTime = isEvent ? deadline.endTime : deadline.time;
4816
- if (closingTime) {
4817
- const parts = new Intl.DateTimeFormat('en', {
4818
- timeZone: deadline.timeZone ?? 'Asia/Seoul',
4819
- year: 'numeric',
4820
- month: '2-digit',
4821
- day: '2-digit',
4822
- hour: '2-digit',
4823
- minute: '2-digit',
4824
- second: '2-digit',
4825
- hourCycle: 'h23',
4826
- }).formatToParts(now);
4827
- const values = Object.fromEntries(parts.map(({ type, value }) => [type, value]));
4828
- const localNow = `${values.year}-${values.month}-${values.day} ${values.hour}:${values.minute}:${values.second}`;
4829
- const closes = `${endDate} ${fullClock(closingTime)}`;
4830
- if (closes <= localNow)
4831
- return [];
4832
- }
4833
- }
4834
- catch {
4835
- return [];
4836
- }
4837
- return [
4838
- {
4839
- reminder,
4840
- days,
4841
- ms,
4842
- url: url.href.replace(/[()]/g, (value) => encodeURIComponent(value)),
4843
- },
4844
- ];
4845
- })
4846
- .sort((a, b) =>
4847
- // The five-row limit must not let older ongoing events displace
4848
- // today's or upcoming deadlines/events. Ongoing events fill spare rows.
4849
- Number(a.days < 0) - Number(b.days < 0) ||
4850
- a.ms - b.ms ||
4851
- (a.reminder.deadline.time ?? '23:59:59').localeCompare(b.reminder.deadline.time ?? '23:59:59'));
4852
- const seen = new Set();
4853
- const lines = [];
4854
- for (const { reminder, days, url } of rows) {
4855
- const d = reminder.deadline;
4856
- const key = JSON.stringify([
4857
- url,
4858
- d.type ?? 'deadline',
4859
- d.title,
4860
- d.kind,
4861
- d.date,
4862
- d.time,
4863
- d.endDate ?? null,
4864
- d.endTime ?? null,
4865
- ]);
4866
- if (seen.has(key))
4867
- continue;
4868
- seen.add(key);
4869
- const isEvent = d.type === 'event';
4870
- const time = d.time ? ` ${d.time}` : '';
4871
- const end = isEvent && d.endDate
4872
- ? d.endDate !== d.date
4873
- ? ` ~ ${d.endDate}${d.endTime ? ` ${d.endTime}` : ''}`
4874
- : d.endTime
4875
- ? ` ~ ${d.endTime}`
4876
- : ''
4877
- : '';
4878
- const zone = (d.time || (isEvent && d.endTime)) && d.timeZone
4879
- ? ` (${escapeLabel(d.timeZone)})`
4880
- : '';
4881
- const timing = days > 0
4882
- ? `D-${days}`
4883
- : days < 0
4884
- ? '진행 중'
4885
- : isEvent
4886
- ? /공개/.test(d.kind)
4887
- ? '오늘 공개'
4888
- : '오늘 개최'
4889
- : '오늘 마감';
4890
- const label = d.title.includes(d.kind) ? d.title : `${d.title} · ${d.kind}`;
4891
- lines.push(`| [${escapeLabel(label)}](${url}) | **${d.date}${time}${end}${zone} · ${timing}** |`);
4892
- if (lines.length === 5)
4893
- break;
4894
- }
4895
- return lines.length
4896
- ? `## ⏰ 다가오는 일정·마감\n\n| 안내 | 일정 |\n| --- | --- |\n${lines.join('\n')}`
4897
- : '';
4898
- }
4899
-
4900
5078
  function canonicalSourceUrl(value) {
4901
5079
  try {
4902
5080
  const url = new URL(value);
@@ -5007,6 +5185,7 @@ class ContentGenerateProvider {
5007
5185
  articleRepository;
5008
5186
  newsletterRepository;
5009
5187
  templateOptions;
5188
+ selectDeadlineReminders;
5010
5189
  _issueOrder = null;
5011
5190
  deadlineRemindersMarkdown;
5012
5191
  model;
@@ -5015,10 +5194,13 @@ class ContentGenerateProvider {
5015
5194
  htmlTemplate;
5016
5195
  /** Newsletter brand name (defaults to config, can be overridden via constructor) */
5017
5196
  newsletterBrandName;
5018
- constructor(model, articleRepository, newsletterRepository, templateOptions, brandName) {
5197
+ constructor(model, articleRepository, newsletterRepository, templateOptions, brandName,
5198
+ /** Chooses displayed reminders; omitted, the first rows by date display. */
5199
+ selectDeadlineReminders) {
5019
5200
  this.articleRepository = articleRepository;
5020
5201
  this.newsletterRepository = newsletterRepository;
5021
5202
  this.templateOptions = templateOptions;
5203
+ this.selectDeadlineReminders = selectDeadlineReminders;
5022
5204
  this.model = model;
5023
5205
  this.deadlineRemindersMarkdown =
5024
5206
  templateOptions?.deadlineRemindersMarkdown?.trim() ?? '';
@@ -5086,9 +5268,9 @@ class ContentGenerateProvider {
5086
5268
  throw new Error('Generated body contains the sharing link before the closing block');
5087
5269
  const reminders = collectNewsletterDeadlines(newsletter.content, usedArticles, this.templateOptions?.verifiedDeadlineReminders ?? []);
5088
5270
  const markdown = this.templateOptions?.verifiedDeadlineReminders !== undefined
5089
- ? renderVerifiedDeadlineReminders(reminders, newsletter.date)
5271
+ ? await this.renderDeadlineReminders(reminders, newsletter.date)
5090
5272
  : this.deadlineRemindersMarkdown ||
5091
- renderVerifiedDeadlineReminders(reminders, newsletter.date);
5273
+ (await this.renderDeadlineReminders(reminders, newsletter.date));
5092
5274
  const share = this.templateOptions?.shareNoticeMarkdown ??
5093
5275
  `이 소식이 도움이 되셨다면 동료 연구자에게도 소개해주시면 좋겠습니다. [${escapeLabel(this.newsletterBrandName)} 구독하기](${this.subscribePageUrl})`;
5094
5276
  // Render only the closing block with the original stylesheet. Keep core's
@@ -5113,6 +5295,12 @@ class ContentGenerateProvider {
5113
5295
  },
5114
5296
  });
5115
5297
  }
5298
+ async renderDeadlineReminders(reminders, publicationDate) {
5299
+ if (!this.selectDeadlineReminders)
5300
+ return renderVerifiedDeadlineReminders(reminders, publicationDate);
5301
+ const rows = eligibleDeadlineReminders(reminders, publicationDate);
5302
+ return formatDeadlineReminders(await this.selectDeadlineReminders(rows, publicationDate));
5303
+ }
5116
5304
  }
5117
5305
 
5118
5306
  /**
@@ -5599,7 +5787,24 @@ function createNewsletterGenerator(dependencies) {
5599
5787
  : dependencies.contentGeneration
5600
5788
  ? createContentGenerationModel(dependencies.contentGeneration)
5601
5789
  : resolveModel('generateNewsletter');
5602
- const contentGenerateProvider = new ContentGenerateProvider(contentModel, dependencies.articleRepository, dependencies.newsletterRepository, templateOptions, resolvedBrandName);
5790
+ const contentGenerateProvider = new ContentGenerateProvider(contentModel, dependencies.articleRepository, dependencies.newsletterRepository, templateOptions, resolvedBrandName,
5791
+ // Reminder selection judges relevance the way importance scoring does, so
5792
+ // it reuses that model rather than adding another configuration knob.
5793
+ createDeadlineReminderSelector({
5794
+ model: resolveModel('determineImportance'),
5795
+ onFallback: (reason, candidateCount) => {
5796
+ dependencies.logger?.info({
5797
+ event: 'newsletter.deadlines.selection.fallback',
5798
+ data: { reason, candidateCount },
5799
+ });
5800
+ },
5801
+ onSelected: (data) => {
5802
+ dependencies.logger?.info({
5803
+ event: 'newsletter.deadlines.selection',
5804
+ data,
5805
+ });
5806
+ },
5807
+ }));
5603
5808
  return new GenerateNewsletter({
5604
5809
  contentOptions: resolvedContentOptions,
5605
5810
  promptProvider: dependencies.promptProvider ?? researchRadarPromptProvider,
@@ -6124,5 +6329,5 @@ async function refreshResearchRadarDeadlines(config) {
6124
6329
  }
6125
6330
  }
6126
6331
 
6127
- export { AnalysisProvider, ContentGenerateProvider, CrawlingProvider, DateService, TaskService, contentOptions, createCrawlingTargetGroups, extractResearchRadarDeadlines, fetchResearchRadarDeadlineSource, generateNewsletter, generateWelcomeHTML, getSourceList, llmConfig, maximumImportanceScoreByDomain, newsletterConfig, refreshResearchRadarDeadlines, renderVerifiedDeadlineReminders, researchRadarPromptProvider, robotsExemptOrigins };
6332
+ export { AnalysisProvider, ContentGenerateProvider, CrawlingProvider, DEADLINE_REMINDER_LEAD_DAYS, DEADLINE_REMINDER_LIMIT, DateService, TaskService, contentOptions, createCrawlingTargetGroups, createDeadlineReminderSelector, extractResearchRadarDeadlines, fetchResearchRadarDeadlineSource, generateNewsletter, generateWelcomeHTML, getSourceList, llmConfig, maximumImportanceScoreByDomain, newsletterConfig, refreshResearchRadarDeadlines, renderVerifiedDeadlineReminders, researchRadarPromptProvider, robotsExemptOrigins };
6128
6333
  //# sourceMappingURL=index.js.map
package/dist/index.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
1
+ {"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
package/package.json CHANGED
@@ -2,7 +2,7 @@
2
2
  "name": "@heripo/research-radar",
3
3
  "private": false,
4
4
  "type": "module",
5
- "version": "6.0.2",
5
+ "version": "6.1.0",
6
6
  "description": "AI-driven intelligence for Korean cultural heritage. This package serves as both a ready-to-use newsletter service and a practical implementation example for the LLM-Newsletter-Kit.",
7
7
  "main": "dist/index.js",
8
8
  "types": "dist/index.d.ts",
@@ -65,7 +65,7 @@
65
65
  },
66
66
  "devDependencies": {
67
67
  "@eslint/js": "^10.0.1",
68
- "@llm-newsletter-kit/core": "^3.1.2",
68
+ "@llm-newsletter-kit/core": "^3.1.3",
69
69
  "@trivago/prettier-plugin-sort-imports": "^6.0.2",
70
70
  "@types/express": "^5.0.6",
71
71
  "@types/jsdom": "^30.0.0",
@@ -110,7 +110,7 @@
110
110
  "example"
111
111
  ],
112
112
  "engines": {
113
- "node": "^24.15.0 || >=26.0.0"
113
+ "node": "^24.22.1 || >=26.12.1"
114
114
  },
115
115
  "publishConfig": {
116
116
  "access": "public"
@@ -120,7 +120,7 @@
120
120
  "fsevents@2.3.3": true
121
121
  },
122
122
  "overrides": {
123
- "body-parser": "^2.3.0",
123
+ "body-parser": "^2.4.0",
124
124
  "postcss": "^8.5.23"
125
125
  }
126
126
  }