@heripo/research-radar 6.1.0 → 6.2.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
@@ -23,7 +23,7 @@ Previously reported service metrics were $0.2–1 per issue and 15% CTR. These a
23
23
 
24
24
  - Type-safe TypeScript with strict interfaces
25
25
  - Provider pattern for swapping components (Crawling/Analysis/Content/Email)
26
- - 74 active crawling targets across heritage agencies, museums, academic societies, filtered at runtime by robots.txt
26
+ - 73 active crawling targets across heritage agencies, museums, academic societies, filtered at runtime by robots.txt, plus newly published journal issues injected by the application
27
27
  - OpenAI GPT-6 defaults for every LLM task, with per-task model overrides
28
28
  - Built-in retries, chain options, preview emails
29
29
 
@@ -263,6 +263,7 @@ formats, omit it for the default, or pass an empty string to suppress it.
263
263
  | `templateOptions` | Default or KRAS newsletter branding and Markdown sections (see below) |
264
264
  | `promptProvider` | Core `PromptProvider` overriding the package's own LLM prompts entirely; omit to use the package's prompts, which fall back to core's defaults |
265
265
  | `excavationReportSource` | Supplies 국가유산청 발굴조사 보고서 entries from the application; that board is then never crawled. Omit to crawl it as before |
266
+ | `journalIssueSource` | Supplies newly published journal issues (such as KCI) from the application, one article per issue. Omit and that target collects nothing |
266
267
  | `previewNewsletter` | Fetch a saved `Newsletter` and send it through a supplied core `EmailService` |
267
268
 
268
269
  `previewNewsletter` requires `fetchNewsletterForPreview: () => Promise<Newsletter>`, `emailService` (with `send(message)`), and `emailMessage` (core `EmailMessage` without `subject`, `html`, or `text`). The core fills those three fields and skips preview delivery when no newsletter was created. Ensure the callback fetches the issue saved by this run.
@@ -340,20 +341,24 @@ The optional `contentGeneration: { provider, apiKey, model? }` compatibility pat
340
341
 
341
342
  | Group | Active | Commented out |
342
343
  | ---------- | -----: | ------------: |
343
- | News | 57 | 1 |
344
+ | News | 56 | 1 |
344
345
  | Business | 5 | 0 |
345
346
  | Employment | 12 | 0 |
346
- | **Total** | **74** | **1** |
347
+ | **Total** | **73** | **1** |
347
348
 
348
- Only the excavation status board stays commented out, as low-value fragmented data. Boards that a site's robots.txt restricts are configured normally and refused at runtime by the robots.txt check, so the configuration does not have to track each site's policy by hand. With current policies 14 of the 74 targets are refused.
349
+ Only the excavation status board stays commented out, as low-value fragmented data. Boards that a site's robots.txt restricts are configured normally and refused at runtime by the robots.txt check, so the configuration does not have to track each site's policy by hand. With current policies 14 of the 73 targets are refused.
349
350
 
350
351
  Three targets are read from data.go.kr open APIs instead of scraped: 나라일터 (`PblJobService`) and 알리오 (`recruitment`) under Employment, and 나라장터 (`BidPublicInfoService`) under Business. Each is a single round of requests, and `publicDataApiKey` supplies the service key — omit it and they answer with an empty list without making a request. The boards carry every public-sector vacancy and procurement notice in the country, so both are narrowed before analysis. The job boards use `src/crawling/heritage-job-filter.ts`, whose exclusions are role nouns and hold up as patterns; roughly 2% of postings survive, about 2.6 a day. 나라장터 instead uses `src/crawling/heritage-triage.ts`, which asks a cheap model about 100 titles per request: heritage vocabulary cannot be settled by substring in Korean, and the deterministic filter remains behind it as the fallback when a batch fails.
351
352
 
353
+ Newly published journal issues are not crawled. The application supplies them through `journalIssueSource` — heripo-web reads them from its KCI paper catalog — and the `KCI_학술지_신간` target serves them from that source, so its URL is never requested. Each issue (권호) becomes one article: its `uniqId` is the issue's `externalId` and its URL the issue's `url`. `usedArticles` carry only the application's article id and URL, so the application records which issues a saved newsletter introduced through the `uniqId` it stored in `saveCrawledArticles`, or through the issue URL. The article body, which scoring sees, lists every paper with its authors, keywords and an abstract truncated to 300 characters, after the keywords several papers share. Without a source the target answers with an empty list. This replaces the former crawl of the 국립문화유산연구원 헤리티지:역사와 과학 and 보존과학연구 boards.
354
+
355
+ The generation model never writes about these issues. `ContentGenerateProvider` takes them out of its candidates and renders a `📖 새로 나온 학술지` section itself, placed before `📑 사업·입찰 공고` (or `📌 마무리` when there is no procurement section). Each issue links to its KCI table of contents and shows, as a table with their authors, the papers its readers would want to read, most interesting first; the rest are collapsed into a count and their topics. The criterion is the readers' interest, not academic discipline — a 역사학 paper can be left out and a non-archaeology one shown — and the readers are 한국고고학회 회원 in KRAS mode. The importance model only chooses and orders paper indices and names the topics of the papers it leaves out — titles, links and authors come from the injected data. If the selection fails or times out, every paper is listed; if the run cannot load the issues, the articles go to the model as ordinary candidates. The held-aside articles are appended to `usedArticles`, so they are recorded with the issue even though the model never saw them. As a result the title, briefing and 마무리 do not mention journals, and journal issues do not count toward the publication criteria.
356
+
352
357
  Crawling fetches pass through that check (`src/crawling/robots.ts`) before reaching the network: a disallowed request is refused rather than sent, and a missing or unreachable robots.txt allows it. `robotsExemptOrigins` in `src/config/index.ts` lists origins exempted from the check, each with its reason.
353
358
 
354
359
  Sources include the Korea Heritage Service, National Research Institute of Cultural Heritage, National Research Institute of Maritime Heritage, Korea Heritage Agency, Korea Association of Archaeological Heritage, archaeological societies, and national museums.
355
360
 
356
- [src/parsers/](./src/parsers/) contains 23 organization-specific parser modules plus shared date and URL utilities. List parsers return `ParsedTargetListItem[]` (title, date, detail URL, date type, and optional source ID); detail parsers return Markdown `detailContent` and attachment/image flags. Parsers can be synchronous or asynchronous. KRAS, Yeongnam Archaeological Society, and maritime heritage sources use additional API requests for client-rendered content.
361
+ [src/parsers/](./src/parsers/) contains 24 parser modules (23 organization-specific, plus the injected journal issue adapter) plus shared date and URL utilities. List parsers return `ParsedTargetListItem[]` (title, date, detail URL, date type, and optional source ID); detail parsers return Markdown `detailContent` and attachment/image flags. Parsers can be synchronous or asynchronous. KRAS, Yeongnam Archaeological Society, and maritime heritage sources use additional API requests for client-rendered content.
357
362
 
358
363
  `CrawlingProvider` uses a maximum concurrency of 5 and wraps the supplied fetch to route KRAS public detail URLs to its detail API, while retaining public URLs in article metadata. When constructing your own pipeline, use the provider's fetch together with its target groups.
359
364
 
@@ -365,7 +370,7 @@ import { getSourceList } from '@heripo/research-radar';
365
370
  const groups = getSourceList(); // [{ id, name, sources: [{ id, name, url }] }]
366
371
  ```
367
372
 
368
- `createCrawlingTargetGroups(customFetch?)`, `getSourceList()`, `contentOptions`, `newsletterConfig`, `llmConfig`, and `researchRadarPromptProvider` are public exports. `ExcavationReport` and `ExcavationReportSource` are exported as types. The package also exports the three provider classes, `DateService`, `TaskService`, and their public configuration/dependency types through [src/index.ts](./src/index.ts).
373
+ `createCrawlingTargetGroups(customFetch?)`, `getSourceList()`, `contentOptions`, `newsletterConfig`, `llmConfig`, `researchRadarPromptProvider`, and `JOURNAL_ISSUE_LIST_URL` (the journal issue target's URL, for finding the issue articles an application saved) are public exports. `ExcavationReport`, `ExcavationReportSource`, `JournalIssue`, `JournalIssuePaper`, and `JournalIssueSource` are exported as types. The package also exports the three provider classes, `DateService`, `TaskService`, and their public configuration/dependency types through [src/index.ts](./src/index.ts).
369
374
 
370
375
  ## Email templates
371
376
 
@@ -497,7 +502,7 @@ Use repeatable `--skip-target=<id-or-name>` or `--skip-target <id-or-name>` to e
497
502
 
498
503
  **Output**: Console table summary + compact text summary for CI integrations.
499
504
 
500
- **CI**: [.github/workflows/parser-health-check.yml](./.github/workflows/parser-health-check.yml) runs daily at 08:00 UTC (17:00 KST), or manually, on an `org-linux` runner with a 30-minute job timeout. It skips the two KHS excavation report/site-open targets. For crawling targets, the health-check composes the same fetch as production — robots.txt gate, then the KRAS detail adapter — so disallowed boards are reported as skipped rather than failed: 16 skipped and 55 checked with the current configuration. The detail check tries up to three list items, so one unreadable post at the top of a board does not fail the target. Slack notifications require the `SLACK_BOT_TOKEN` secret and `SLACK_ALERT_DEV_CHANNEL` repository variable. Forks need a matching runner and notification configuration to use this workflow unchanged. The CLI also writes GitHub Actions outputs and a job summary when their environment variables are present.
505
+ **CI**: [.github/workflows/parser-health-check.yml](./.github/workflows/parser-health-check.yml) runs daily at 08:00 UTC (17:00 KST), or manually, on an `org-linux` runner with a 30-minute job timeout. It skips the two KHS excavation report/site-open targets. For crawling targets, the health-check composes the same fetch as production — robots.txt gate, then the KRAS detail adapter — so disallowed boards are reported as skipped rather than failed: 17 skipped (including the injected journal issue target, which has no live board) and 53 checked with the current configuration. The detail check tries up to three list items, so one unreadable post at the top of a board does not fail the target. Slack notifications require the `SLACK_BOT_TOKEN` secret and `SLACK_ALERT_DEV_CHANNEL` repository variable. Forks need a matching runner and notification configuration to use this workflow unchanged. The CLI also writes GitHub Actions outputs and a job summary when their environment variables are present.
501
506
 
502
507
  ## 🤝 Contributing
503
508
 
package/dist/index.d.ts CHANGED
@@ -126,6 +126,77 @@ interface ExcavationReport {
126
126
  * Called at most once per generation run.
127
127
  */
128
128
  type ExcavationReportSource = () => Promise<ExcavationReport[]>;
129
+ /**
130
+ * One paper in an injected journal issue.
131
+ */
132
+ interface JournalIssuePaper {
133
+ /** Paper title. */
134
+ title: string;
135
+ /** Author names in publication order. */
136
+ authors: string[];
137
+ /** Author keywords. Blank and repeated keywords are ignored. */
138
+ keywords: string[];
139
+ /**
140
+ * Abstract shown to the scoring and generation models, in the original
141
+ * language when the source has one. Truncated before it reaches them.
142
+ */
143
+ abstract?: string | null;
144
+ /** Public page for the paper, such as its KCI article page. */
145
+ url: string;
146
+ }
147
+ /**
148
+ * A newly published journal issue (권호) supplied by the application.
149
+ *
150
+ * Each issue becomes one article whose body lists every paper it carries, so a
151
+ * twenty-paper issue is scored and introduced once rather than twenty times.
152
+ */
153
+ interface JournalIssue {
154
+ /**
155
+ * Stable identifier for the issue, such as
156
+ * `{journalId}|{year}|{month}|{volume}|{issue}`. It becomes the article's
157
+ * `uniqId` and reaches `saveCrawledArticles`, so the application can store
158
+ * it with the article. `usedArticles` carry only the article's own id and
159
+ * URL, so that stored value (or the issue `url`) is how the application maps
160
+ * a saved newsletter back to the issues it introduced. Keep it independent
161
+ * of the paper list, or a later snapshot of the same issue looks like a new
162
+ * one.
163
+ */
164
+ externalId: string;
165
+ /**
166
+ * Public page readers follow from the newsletter. It is also the article's
167
+ * URL, so it must be stable for the issue: previously saved issues are
168
+ * recognized by it and not saved again.
169
+ */
170
+ url: string;
171
+ /** Journal name, e.g. "헤리티지:역사와 과학". */
172
+ journalName: string;
173
+ /** Publication year. */
174
+ publishedYear: number;
175
+ /** Publication month, 1-12. */
176
+ publishedMonth: number;
177
+ /** Volume (권). Empty when the journal numbers issues only. */
178
+ volume: string;
179
+ /** Issue number (호). Empty when the journal numbers volumes only. */
180
+ issue: string;
181
+ /**
182
+ * Date the issue became available to the application, in ISO format
183
+ * (YYYY-MM-DD, Korean time) — for example when its papers were first
184
+ * collected. Used as the article's registered date.
185
+ * @example "2026-10-28"
186
+ */
187
+ registeredDate: IsoDateString;
188
+ /** Every paper in the issue, in the order to list them. */
189
+ papers: JournalIssuePaper[];
190
+ }
191
+ /**
192
+ * Supplies newly published journal issues from the application, such as those
193
+ * collected from KCI.
194
+ *
195
+ * The journal issue target has no live board behind it: when this is omitted
196
+ * the target collects nothing and makes no request. Called at most once per
197
+ * generation run.
198
+ */
199
+ type JournalIssueSource = () => Promise<JournalIssue[]>;
129
200
  /**
130
201
  * Repository interface for tag management
131
202
  */
@@ -362,6 +433,17 @@ interface NewsletterGeneratorDependencies {
362
433
  * it to keep crawling the board as before. No other target is affected.
363
434
  */
364
435
  excavationReportSource?: ExcavationReportSource;
436
+ /**
437
+ * Supplies newly published journal issues from the application (optional),
438
+ * such as those collected from KCI.
439
+ *
440
+ * Each issue becomes one article listing its papers. The target has no live
441
+ * board, so omitting this leaves it empty without making a request. The
442
+ * article's `uniqId` is the issue's `externalId` and its URL the issue's
443
+ * `url`; store either when articles are saved to record which issues a
444
+ * saved newsletter introduced.
445
+ */
446
+ journalIssueSource?: JournalIssueSource;
365
447
  /**
366
448
  * data.go.kr service key for the 나라일터 and 알리오 job boards (optional).
367
449
  *
@@ -402,6 +484,15 @@ interface NewsletterGeneratorDependencies {
402
484
  */
403
485
  declare function generateNewsletter(dependencies: NewsletterGeneratorDependencies): Promise<string | number | null>;
404
486
 
487
+ /**
488
+ * Board URL of the journal issue target.
489
+ *
490
+ * There is no list page behind it: the adapter below answers it from the
491
+ * application's injected issues and never sends it. It points at KCI because
492
+ * that is where the issues come from, and it is what the source list shows.
493
+ */
494
+ declare const JOURNAL_ISSUE_LIST_URL = "https://www.kci.go.kr/kciportal/main.kci";
495
+
405
496
  /**
406
497
  * Generates a welcome email HTML string with CSS inlined via juice.
407
498
  *
@@ -568,6 +659,38 @@ type DeadlineReminderSelectorOptions = {
568
659
  */
569
660
  declare const createDeadlineReminderSelector: (options: DeadlineReminderSelectorOptions) => DeadlineReminderSelector;
570
661
 
662
+ /** Memoized access to one run's injected journal issues. */
663
+ type JournalIssueLoader = () => Promise<JournalIssue[]>;
664
+
665
+ /** Which papers of an issue the table shows, and which it summarizes. */
666
+ type JournalPaperSelection = {
667
+ /** Paper indices shown in the table, most interesting first. */
668
+ featured: number[];
669
+ /** Papers collapsed into a count and topic summary, in paper order. */
670
+ others: {
671
+ index: number;
672
+ topic: string | null;
673
+ }[];
674
+ };
675
+ /**
676
+ * Picks the papers the newsletter's readers would want to see, or returns null
677
+ * when no selection could be made — the section then lists every paper.
678
+ */
679
+ type JournalPaperSelector = (issue: JournalIssue) => Promise<JournalPaperSelection | null>;
680
+
681
+ /**
682
+ * Injected journal issues are rendered by the provider rather than written by
683
+ * the model: each is a table of up to twenty titles and author lists, which
684
+ * the model would have to copy exactly.
685
+ */
686
+ type JournalIssueRendering = {
687
+ /** The run's injected issues, matched to candidates by URL. */
688
+ load: JournalIssueLoader;
689
+ /** Picks the papers readers would care about; omitted, every paper is listed. */
690
+ select?: JournalPaperSelector;
691
+ /** Reports that the issues could not be loaded, so the model got them. */
692
+ onUnavailable?: (reason: string) => void;
693
+ };
571
694
  /**
572
695
  * Content generation provider implementation
573
696
  * - LLM-based newsletter content generation
@@ -580,8 +703,10 @@ declare class ContentGenerateProvider implements ContentGenerateProvider$1 {
580
703
  private readonly templateOptions?;
581
704
  /** Chooses displayed reminders; omitted, the first rows by date display. */
582
705
  private readonly selectDeadlineReminders?;
706
+ private readonly journalIssues?;
583
707
  private _issueOrder;
584
708
  private readonly deadlineRemindersMarkdown;
709
+ private heldJournalIssues;
585
710
  readonly model: LanguageModel;
586
711
  readonly fetchRecentTitles?: ContentGenerateProvider$1['fetchRecentTitles'];
587
712
  /** HTML template with markers for title and content injection */
@@ -590,7 +715,7 @@ declare class ContentGenerateProvider implements ContentGenerateProvider$1 {
590
715
  newsletterBrandName: string;
591
716
  constructor(model: LanguageModel, articleRepository: ArticleRepository, newsletterRepository: NewsletterRepository, templateOptions?: NewsletterTemplateOptions | undefined, brandName?: string,
592
717
  /** Chooses displayed reminders; omitted, the first rows by date display. */
593
- selectDeadlineReminders?: DeadlineReminderSelector | undefined);
718
+ selectDeadlineReminders?: DeadlineReminderSelector | undefined, journalIssues?: JournalIssueRendering | undefined);
594
719
  /** LLM temperature setting for content generation */
595
720
  temperature: number;
596
721
  /** Subscribe page URL */
@@ -625,6 +750,7 @@ declare class ContentGenerateProvider implements ContentGenerateProvider$1 {
625
750
  }): Promise<{
626
751
  id: string | number;
627
752
  }>;
753
+ private renderJournalIssues;
628
754
  private renderDeadlineReminders;
629
755
  }
630
756
 
@@ -658,7 +784,7 @@ declare class CrawlingProvider implements CrawlingProvider$1 {
658
784
  customFetch?: typeof fetch;
659
785
  /** Crawling target groups configuration */
660
786
  crawlingTargetGroups: CrawlingTargetGroup[];
661
- constructor(articleRepository: ArticleRepository, customFetch?: typeof fetch, excavationReportSource?: ExcavationReportSource, logger?: AppLogger, publicDataApiKey?: string, bidTriage?: HeritageBidTriage);
787
+ constructor(articleRepository: ArticleRepository, customFetch?: typeof fetch, excavationReportSource?: ExcavationReportSource, logger?: AppLogger, publicDataApiKey?: string, bidTriage?: HeritageBidTriage, journalIssueSource?: JournalIssueSource);
662
788
  /**
663
789
  * Fetch existing articles by URLs to avoid duplicate crawling
664
790
  * @param articleUrls - URLs to check
@@ -854,5 +980,5 @@ declare function fetchResearchRadarDeadlineSource({ source, customFetch, publicD
854
980
  /** Only explicit, grounded results are verified. Missing dates are never cancellation. */
855
981
  declare function refreshResearchRadarDeadlines(config: ResearchRadarDeadlineRefreshConfig): Promise<ResearchRadarDeadlineRefreshResult>;
856
982
 
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 };
983
+ export { AnalysisProvider, ContentGenerateProvider, CrawlingProvider, DEADLINE_REMINDER_LEAD_DAYS, DEADLINE_REMINDER_LIMIT, DateService, JOURNAL_ISSUE_LIST_URL, TaskService, contentOptions, createCrawlingTargetGroups, createDeadlineReminderSelector, extractResearchRadarDeadlines, fetchResearchRadarDeadlineSource, generateNewsletter, generateWelcomeHTML, getSourceList, llmConfig, maximumImportanceScoreByDomain, newsletterConfig, refreshResearchRadarDeadlines, renderVerifiedDeadlineReminders, researchRadarPromptProvider, robotsExemptOrigins };
984
+ export type { ArticleRepository, ContentGenerationConfig, ContentOptions, DeadlineReminderSelector, DeadlineReminderSelectorOptions, DeadlineVerificationFailure, EligibleDeadlineReminder, ExcavationReport, ExcavationReportSource, JournalIssue, JournalIssuePaper, JournalIssueSource, 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$1(candidates) {
203
+ function buildUserPrompt$2(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$1(candidates),
221
+ prompt: buildUserPrompt$2(candidates),
222
222
  abortSignal: signal,
223
223
  });
224
224
  const verdicts = new Array(candidates.length).fill(false);
@@ -551,7 +551,7 @@ function renderVerifiedDeadlineReminders(reminders, publicationDate, now = new D
551
551
  * are discarded rather than trusted. Duplicates are named separately so a short
552
552
  * selection can be filled without restoring an event the model merged.
553
553
  */
554
- const SELECT_SCHEMA = jsonSchema({
554
+ const SELECT_SCHEMA$1 = jsonSchema({
555
555
  type: 'object',
556
556
  properties: {
557
557
  select: {
@@ -568,7 +568,7 @@ const SELECT_SCHEMA = jsonSchema({
568
568
  required: ['select', 'duplicates'],
569
569
  additionalProperties: false,
570
570
  });
571
- const systemPrompt = (limit) => `너는 한국 고고학·문화유산 뉴스레터의 "다가오는 일정·마감" 안내를 고른다.
571
+ const systemPrompt$1 = (limit) => `너는 한국 고고학·문화유산 뉴스레터의 "다가오는 일정·마감" 안내를 고른다.
572
572
 
573
573
  독자는 고고학·문화유산 연구자, 발굴·조사기관 종사자, 학예 인력, 관련 전공 학생이다.
574
574
  후보는 모두 원문에서 다시 확인한 일정이다. 날짜·제목은 바꿀 수 없고, 너는 번호만 고른다.
@@ -593,7 +593,7 @@ function timingOf({ days, reminder }) {
593
593
  function clockOf(date, time) {
594
594
  return time ? `${date} ${time}` : date;
595
595
  }
596
- function buildUserPrompt(rows, publicationDate, limit) {
596
+ function buildUserPrompt$1(rows, publicationDate, limit) {
597
597
  const lines = rows.map((row, index) => {
598
598
  const { deadline, recentReminderCount } = row.reminder;
599
599
  const start = clockOf(deadline.date, deadline.time);
@@ -644,9 +644,9 @@ const createDeadlineReminderSelector = (options) => {
644
644
  const { output, usage } = await Promise.race([
645
645
  generateText({
646
646
  model: options.model,
647
- output: Output.object({ schema: SELECT_SCHEMA }),
648
- system: systemPrompt(limit),
649
- prompt: buildUserPrompt(rows, publicationDate, limit),
647
+ output: Output.object({ schema: SELECT_SCHEMA$1 }),
648
+ system: systemPrompt$1(limit),
649
+ prompt: buildUserPrompt$1(rows, publicationDate, limit),
650
650
  abortSignal: controller.signal,
651
651
  }),
652
652
  new Promise((_, reject) => {
@@ -697,6 +697,184 @@ const createDeadlineReminderSelector = (options) => {
697
697
  };
698
698
  };
699
699
 
700
+ /**
701
+ * Shares one call of the application's source between the crawl, which turns
702
+ * issues into articles, and generation, which renders them as tables.
703
+ *
704
+ * A rejected call is forgotten, so a failure while crawling does not decide
705
+ * what generation sees: the next caller asks the source again. A call that
706
+ * does not settle within `timeoutMs` is rejected and forgotten the same way,
707
+ * so a stalled source cannot hold generation, which has no request timeout of
708
+ * its own.
709
+ *
710
+ * @param timeoutMs - Milliseconds before a source call is given up
711
+ */
712
+ function createJournalIssueLoader(source, timeoutMs = 60_000) {
713
+ let pending = null;
714
+ return () => {
715
+ if (pending)
716
+ return pending;
717
+ let timer;
718
+ const call = Promise.race([
719
+ source(),
720
+ new Promise((_, reject) => {
721
+ timer = setTimeout(() => reject(new Error(`journal issue source timed out after ${timeoutMs}ms`)), timeoutMs);
722
+ }),
723
+ ])
724
+ .catch((error) => {
725
+ if (pending === call)
726
+ pending = null;
727
+ throw error;
728
+ })
729
+ .finally(() => clearTimeout(timer));
730
+ pending = call;
731
+ return call;
732
+ };
733
+ }
734
+
735
+ /**
736
+ * Asks for paper indices, never for titles or authors.
737
+ *
738
+ * Rendering stays on the injected papers, so the model can only choose and
739
+ * order them; it cannot rename one or alter its authors. The only text it
740
+ * supplies is the short topic label of a paper it left out of the table.
741
+ */
742
+ const SELECT_SCHEMA = jsonSchema({
743
+ type: 'object',
744
+ properties: {
745
+ featured: {
746
+ type: 'array',
747
+ items: { type: 'integer' },
748
+ description: '독자가 관심 가질 논문 번호. 관심이 클 것부터',
749
+ },
750
+ others: {
751
+ type: 'array',
752
+ items: {
753
+ type: 'object',
754
+ properties: {
755
+ index: { type: 'integer' },
756
+ topic: {
757
+ type: 'string',
758
+ description: '논문 주제를 2-12자로 요약한 명사구',
759
+ },
760
+ },
761
+ required: ['index', 'topic'],
762
+ additionalProperties: false,
763
+ },
764
+ description: '독자의 관심사에서 멀어 요약만 할 논문',
765
+ },
766
+ },
767
+ required: ['featured', 'others'],
768
+ additionalProperties: false,
769
+ });
770
+ const systemPrompt = (audience) => `너는 ${audience}에게 보내는 뉴스레터에서 학술지 신간 논문 중 무엇을 표로 소개할지 고른다.
771
+
772
+ 기준은 학문 분야가 아니라 **${audience}이(가) 이 논문을 찾아 읽어볼 만큼 관심을 가질까**다.
773
+ 제목·저자는 바꿀 수 없고, 너는 번호만 고른다. 모든 논문을 featured나 others 중 정확히 한 곳에 넣는다.
774
+
775
+ - featured: 독자가 관심을 가질 논문. 관심이 클 것부터 순서대로 넣는다.
776
+ - 고고학이 아니어도 독자의 연구·실무에 닿으면 넣는다. 예: 고대 환경·기후 복원, 연대측정·성분분석 같은 분석 기법,
777
+ 인골·동물 유존체, 고지도·지명 연구, 전통 건축·토목 기술, 유적·유물을 다루는 문헌사·미술사, 매장유산 제도·정책,
778
+ 문화유산 보존처리, 디지털 기록·GIS·AI의 유산 적용
779
+ - 다루는 대상이 독자의 관심 시대·지역·자료와 직접 맞닿는지 본다.
780
+ - others: 독자의 관심사에서 멀어 제목을 나열할 필요가 없는 논문. topic에 주제를 2-12자 명사구로 쓴다.
781
+ - 역사학·인문학이라도 독자와 거리가 멀면 여기에 넣는다. 예: 근현대 외교·정치사, 사상사·철학, 현대 문학 비평,
782
+ 현대 사회·경제·교육·관광 정책, 유산과 무관한 언어학
783
+ - 애매하면 featured에 넣는다. others는 독자가 거의 찾아보지 않을 논문만이다.`;
784
+ function buildUserPrompt(issue) {
785
+ const lines = issue.papers.map((paper, index) => {
786
+ const keywords = [
787
+ ...new Set(paper.keywords.map((k) => k.trim()).filter(Boolean)),
788
+ ].join(', ');
789
+ const abstract = [...(paper.abstract ?? '').replace(/\s+/g, ' ').trim()]
790
+ .slice(0, 200)
791
+ .join('');
792
+ return `${index}. ${paper.title.replace(/\s+/g, ' ').trim()}${keywords ? ` · 키워드: ${keywords}` : ''}${abstract ? ` · 초록: ${abstract}` : ''}`;
793
+ });
794
+ return `학술지 「${issue.journalName.trim()}」 ${issue.publishedYear}년 ${issue.publishedMonth}월 호의 논문 ${issue.papers.length}편을 나눠라.\n\n${lines.join('\n')}`;
795
+ }
796
+ function normalizeTopic(topic) {
797
+ const normalized = topic.replace(/\s+/g, ' ').trim();
798
+ return normalized && [...normalized].length <= 30 ? normalized : null;
799
+ }
800
+ /**
801
+ * Builds the selector that shows an issue's papers its readers would care
802
+ * about as a table, most interesting first, and collapses the rest into a
803
+ * topic summary.
804
+ *
805
+ * It never fails the newsletter: an error, a timeout or an answer with no
806
+ * usable index falls back to null, and the section lists every paper. A paper
807
+ * the model left out, named in both lists or summarized twice is shown in the
808
+ * table after the chosen ones rather than collapsed, so a malformed answer can
809
+ * only show more, never hide a paper.
810
+ */
811
+ const createJournalPaperSelector = (options) => {
812
+ const fallback = (issue, reason) => {
813
+ options.onFallback?.(reason, issue);
814
+ return null;
815
+ };
816
+ return async (issue) => {
817
+ if (issue.papers.length === 0)
818
+ return { featured: [], others: [] };
819
+ const timeoutMs = options.timeoutMs ?? 60_000;
820
+ const controller = new AbortController();
821
+ let timer;
822
+ try {
823
+ const { output } = await Promise.race([
824
+ generateText({
825
+ model: options.model,
826
+ output: Output.object({ schema: SELECT_SCHEMA }),
827
+ system: systemPrompt(options.audience),
828
+ prompt: buildUserPrompt(issue),
829
+ abortSignal: controller.signal,
830
+ }),
831
+ new Promise((_, reject) => {
832
+ timer = setTimeout(() => {
833
+ controller.abort();
834
+ reject(new Error(`selection timed out after ${timeoutMs}ms`));
835
+ }, timeoutMs);
836
+ }),
837
+ ]);
838
+ const count = issue.papers.length;
839
+ const usable = (index) => Number.isInteger(index) && index >= 0 && index < count;
840
+ const featured = [];
841
+ for (const index of output.featured ?? [])
842
+ if (usable(index) && !featured.includes(index))
843
+ featured.push(index);
844
+ const topics = new Map();
845
+ const repeated = new Set();
846
+ for (const { index, topic } of output.others ?? []) {
847
+ if (!usable(index) || featured.includes(index))
848
+ continue;
849
+ if (topics.has(index))
850
+ repeated.add(index);
851
+ else
852
+ topics.set(index, normalizeTopic(topic));
853
+ }
854
+ // A paper summarized twice is ambiguous, so it is shown rather than hidden.
855
+ for (const index of repeated)
856
+ topics.delete(index);
857
+ if (featured.length === 0 && topics.size === 0)
858
+ return fallback(issue, 'no usable index in the selection');
859
+ for (let index = 0; index < count; index++)
860
+ if (!featured.includes(index) && !topics.has(index))
861
+ featured.push(index);
862
+ return {
863
+ featured,
864
+ others: [...topics]
865
+ .map(([index, topic]) => ({ index, topic }))
866
+ .sort((a, b) => a.index - b.index),
867
+ };
868
+ }
869
+ catch (error) {
870
+ return fallback(issue, error instanceof Error ? error.message : String(error));
871
+ }
872
+ finally {
873
+ clearTimeout(timer);
874
+ }
875
+ };
876
+ };
877
+
700
878
  /**
701
879
  * Reads what data.go.kr said when it refused a request.
702
880
  *
@@ -1061,20 +1239,20 @@ const buildExcavationReportDetailUrl = (externalId) => `${EXCAVATION_BASE_URL}/g
1061
1239
  * Marks a response body as injected report data rather than scraped HTML, so
1062
1240
  * the parsers below can tell the two apart without guessing.
1063
1241
  */
1064
- const INJECTED_MARKER = '@heripo/research-radar:excavation-reports';
1065
- function parseInjectedPayload(body) {
1066
- if (!body.includes(INJECTED_MARKER)) {
1242
+ const INJECTED_MARKER$1 = '@heripo/research-radar:excavation-reports';
1243
+ function parseInjectedPayload$1(body) {
1244
+ if (!body.includes(INJECTED_MARKER$1)) {
1067
1245
  return null;
1068
1246
  }
1069
1247
  try {
1070
1248
  const parsed = JSON.parse(body);
1071
- return parsed.marker === INJECTED_MARKER ? parsed : null;
1249
+ return parsed.marker === INJECTED_MARKER$1 ? parsed : null;
1072
1250
  }
1073
1251
  catch {
1074
1252
  return null;
1075
1253
  }
1076
1254
  }
1077
- function jsonResponse$1(payload) {
1255
+ function jsonResponse$2(payload) {
1078
1256
  return new Response(JSON.stringify(payload), {
1079
1257
  status: 200,
1080
1258
  headers: { 'content-type': 'application/json' },
@@ -1107,8 +1285,8 @@ const createExcavationReportFetch = (baseFetch = fetch, source) => {
1107
1285
  }
1108
1286
  if (url.pathname === new URL(EXCAVATION_REPORT_LIST_URL).pathname) {
1109
1287
  const reports = await loadReports();
1110
- return jsonResponse$1({
1111
- marker: INJECTED_MARKER,
1288
+ return jsonResponse$2({
1289
+ marker: INJECTED_MARKER$1,
1112
1290
  reports,
1113
1291
  });
1114
1292
  }
@@ -1116,8 +1294,8 @@ const createExcavationReportFetch = (baseFetch = fetch, source) => {
1116
1294
  const externalId = url.searchParams.get('ecexmRcno');
1117
1295
  const report = (await loadReports()).find((candidate) => candidate.externalId === externalId);
1118
1296
  if (report) {
1119
- return jsonResponse$1({
1120
- marker: INJECTED_MARKER,
1297
+ return jsonResponse$2({
1298
+ marker: INJECTED_MARKER$1,
1121
1299
  report,
1122
1300
  });
1123
1301
  }
@@ -1133,7 +1311,7 @@ function renderExcavationReportContent(report) {
1133
1311
  return ['## 발굴조사 보고서 정보', '', ...lines].join('\n');
1134
1312
  }
1135
1313
  const parseExcavationReportList = (html) => {
1136
- const injected = parseInjectedPayload(html);
1314
+ const injected = parseInjectedPayload$1(html);
1137
1315
  if (injected) {
1138
1316
  return injected.reports.map((report) => ({
1139
1317
  uniqId: report.externalId,
@@ -1199,7 +1377,7 @@ const parseExcavationSiteList = (html) => {
1199
1377
  return posts;
1200
1378
  };
1201
1379
  const parseExcavationReportDetail = (html) => {
1202
- const injected = parseInjectedPayload(html);
1380
+ const injected = parseInjectedPayload$1(html);
1203
1381
  if (injected) {
1204
1382
  return {
1205
1383
  detailContent: renderExcavationReportContent(injected.report),
@@ -1283,7 +1461,7 @@ function toIsoDate$1(value) {
1283
1461
  const match = /^(\d{4})-(\d{2})-(\d{2})/.exec(value ?? '');
1284
1462
  return match ? `${match[1]}-${match[2]}-${match[3]}` : '';
1285
1463
  }
1286
- function jsonResponse(payload) {
1464
+ function jsonResponse$1(payload) {
1287
1465
  return new Response(JSON.stringify(payload), {
1288
1466
  status: 200,
1289
1467
  headers: { 'content-type': 'application/json' },
@@ -1325,7 +1503,7 @@ const createG2bFetch = (baseFetch = fetch, options) => {
1325
1503
  if (!apiKey) {
1326
1504
  // Without a key the board is simply not collected: answer with an empty
1327
1505
  // payload so the parsers yield nothing and no request is made.
1328
- return jsonResponse({ items: [] });
1506
+ return jsonResponse$1({ items: [] });
1329
1507
  }
1330
1508
  const end = new Date();
1331
1509
  const begin = new Date(end.getTime() - windowHours * 60 * 60 * 1000);
@@ -1419,7 +1597,7 @@ const createG2bFetch = (baseFetch = fetch, options) => {
1419
1597
  for (const notice of heritage) {
1420
1598
  noticeCache.set(`${notice.bidNtceNo}:${notice.bidNtceOrd}`, notice);
1421
1599
  }
1422
- return jsonResponse({ items: heritage });
1600
+ return jsonResponse$1({ items: heritage });
1423
1601
  }
1424
1602
  if (url.pathname === '/link/PNPE027_01/single/') {
1425
1603
  if (refreshDetails) {
@@ -1456,13 +1634,13 @@ const createG2bFetch = (baseFetch = fetch, options) => {
1456
1634
  }
1457
1635
  const latest = revisions.sort((a, b) => Number(b.bidNtceOrd) - Number(a.bidNtceOrd))[0];
1458
1636
  return latest
1459
- ? jsonResponse({ item: latest })
1637
+ ? jsonResponse$1({ item: latest })
1460
1638
  : fail('나라장터 notice not found');
1461
1639
  }
1462
1640
  const key = `${url.searchParams.get('bidPbancNo')}:${url.searchParams.get('bidPbancOrd')}`;
1463
1641
  const notice = noticeCache.get(key);
1464
1642
  if (notice) {
1465
- return jsonResponse({ item: notice });
1643
+ return jsonResponse$1({ item: notice });
1466
1644
  }
1467
1645
  }
1468
1646
  return baseFetch(input, init);
@@ -2170,6 +2348,226 @@ const parseJinjuMuseumDetail = (html) => {
2170
2348
  };
2171
2349
  };
2172
2350
 
2351
+ /**
2352
+ * Board URL of the journal issue target.
2353
+ *
2354
+ * There is no list page behind it: the adapter below answers it from the
2355
+ * application's injected issues and never sends it. It points at KCI because
2356
+ * that is where the issues come from, and it is what the source list shows.
2357
+ */
2358
+ const JOURNAL_ISSUE_LIST_URL = 'https://www.kci.go.kr/kciportal/main.kci';
2359
+ /** Abstract length kept per paper, so a large issue stays a bounded input. */
2360
+ const ABSTRACT_MAX_LENGTH = 300;
2361
+ /** Keywords listed in the issue summary. */
2362
+ const KEYWORD_SUMMARY_LIMIT = 15;
2363
+ /**
2364
+ * Marks a response body as injected issue data rather than scraped HTML, so
2365
+ * the parsers below can tell the two apart without guessing.
2366
+ */
2367
+ const INJECTED_MARKER = '@heripo/research-radar:journal-issues';
2368
+ function parseInjectedPayload(body) {
2369
+ if (!body.includes(INJECTED_MARKER)) {
2370
+ return null;
2371
+ }
2372
+ try {
2373
+ const parsed = JSON.parse(body);
2374
+ return parsed.marker === INJECTED_MARKER ? parsed : null;
2375
+ }
2376
+ catch {
2377
+ return null;
2378
+ }
2379
+ }
2380
+ function jsonResponse(payload) {
2381
+ return new Response(JSON.stringify(payload), {
2382
+ status: 200,
2383
+ headers: { 'content-type': 'application/json' },
2384
+ });
2385
+ }
2386
+ function requestHref(input) {
2387
+ return typeof input === 'string'
2388
+ ? input
2389
+ : input instanceof URL
2390
+ ? input.href
2391
+ : input.url;
2392
+ }
2393
+ /**
2394
+ * Settles with `promise`, or rejects once `signal` aborts. The promise keeps
2395
+ * running; only this request stops waiting for it, as a network fetch would.
2396
+ */
2397
+ function untilAborted(promise, signal) {
2398
+ if (!signal)
2399
+ return promise;
2400
+ if (signal.aborted)
2401
+ return Promise.reject(signal.reason);
2402
+ return new Promise((resolve, reject) => {
2403
+ const onAbort = () => reject(signal.reason);
2404
+ signal.addEventListener('abort', onAbort, { once: true });
2405
+ promise.then(resolve, reject).finally(() => {
2406
+ signal.removeEventListener('abort', onAbort);
2407
+ });
2408
+ });
2409
+ }
2410
+ /**
2411
+ * Serves the journal issue target from an injected source.
2412
+ *
2413
+ * Core's crawling chain always fetches a target's list URL and then each detail
2414
+ * URL, so the substitution happens at the fetch layer — the same seam
2415
+ * `createExcavationReportFetch` uses. Unlike that board there is nothing to
2416
+ * crawl instead, so the list URL is always answered here: with no source it is
2417
+ * an empty list and no request is made. Detail requests are matched against
2418
+ * the URLs of the issues already served; anything else is delegated.
2419
+ *
2420
+ * `source` is called once and its result reused for the detail requests that
2421
+ * follow. The adapter sits outermost on the fetch every target shares, so only
2422
+ * the list request ever waits on the source: other requests are matched
2423
+ * against issues already served, without awaiting, so a slow or failing source
2424
+ * cannot stall or break the rest of the crawl. Core requests this target's
2425
+ * details only after its list has parsed. A failed source is retried on the
2426
+ * next list request. The list request honors its abort signal, so core's
2427
+ * request timeout ends this target even when the source never settles.
2428
+ *
2429
+ * @param baseFetch - Fetch to delegate every other request to
2430
+ * @param source - Supplies the issues for this run
2431
+ */
2432
+ const createJournalIssueFetch = (baseFetch = fetch, source) => {
2433
+ let pending = null;
2434
+ const issuesByUrl = new Map();
2435
+ const loadIssues = () => (pending ??= (source ? source() : Promise.resolve([])).then((issues) => {
2436
+ for (const issue of issues)
2437
+ issuesByUrl.set(issue.url, issue);
2438
+ return issues;
2439
+ }, (error) => {
2440
+ pending = null;
2441
+ throw error;
2442
+ }));
2443
+ return async (input, init) => {
2444
+ const href = requestHref(input);
2445
+ if (href === JOURNAL_ISSUE_LIST_URL) {
2446
+ return jsonResponse({
2447
+ marker: INJECTED_MARKER,
2448
+ issues: await untilAborted(loadIssues(), init?.signal),
2449
+ });
2450
+ }
2451
+ const issue = issuesByUrl.get(href);
2452
+ if (issue) {
2453
+ return jsonResponse({
2454
+ marker: INJECTED_MARKER,
2455
+ issue,
2456
+ });
2457
+ }
2458
+ return baseFetch(input, init);
2459
+ };
2460
+ };
2461
+ /** "제59권 제3호", or whichever part the journal numbers. */
2462
+ function formatVolumeIssue(issue) {
2463
+ const label = (value, unit) => {
2464
+ const trimmed = value.trim();
2465
+ if (!trimmed)
2466
+ return '';
2467
+ return /^\d+$/.test(trimmed) ? `제${trimmed}${unit}` : trimmed;
2468
+ };
2469
+ // Some journals register the publication year as the volume on KCI
2470
+ // (한국고고학보 2026-3), which would read as "제2026권".
2471
+ const volume = issue.volume.trim() === String(issue.publishedYear) ? '' : issue.volume;
2472
+ return [label(volume, '권'), label(issue.issue, '호')]
2473
+ .filter(Boolean)
2474
+ .join(' ');
2475
+ }
2476
+ function formatJournalIssueTitle(issue) {
2477
+ const volumeIssue = formatVolumeIssue(issue);
2478
+ return [
2479
+ issue.journalName.trim(),
2480
+ volumeIssue,
2481
+ `발간 (${issue.publishedYear}년 ${issue.publishedMonth}월)`,
2482
+ ]
2483
+ .filter(Boolean)
2484
+ .join(' ');
2485
+ }
2486
+ /** Keyword counts by paper. A keyword repeated within one paper counts once. */
2487
+ function countKeywords(papers) {
2488
+ const counts = new Map();
2489
+ for (const paper of papers) {
2490
+ const keywords = new Set(paper.keywords.map((keyword) => keyword.trim()).filter(Boolean));
2491
+ for (const keyword of keywords) {
2492
+ counts.set(keyword, (counts.get(keyword) ?? 0) + 1);
2493
+ }
2494
+ }
2495
+ return [...counts]
2496
+ .map(([keyword, paperCount]) => ({ keyword, paperCount }))
2497
+ .sort((a, b) => b.paperCount - a.paperCount || a.keyword.localeCompare(b.keyword, 'ko'));
2498
+ }
2499
+ function truncate(text, maxLength) {
2500
+ const normalized = text.replace(/\s+/g, ' ').trim();
2501
+ const characters = [...normalized];
2502
+ return characters.length > maxLength
2503
+ ? `${characters.slice(0, maxLength).join('')}…`
2504
+ : normalized;
2505
+ }
2506
+ /** Renders an issue as the article body: summary, keywords, then every paper. */
2507
+ function renderJournalIssueContent(issue) {
2508
+ const volumeIssue = formatVolumeIssue(issue);
2509
+ const lines = [
2510
+ '## 학술지 권호 정보',
2511
+ '',
2512
+ `- **학술지**: ${issue.journalName.trim()}`,
2513
+ `- **발행**: ${issue.publishedYear}년 ${issue.publishedMonth}월`,
2514
+ ...(volumeIssue ? [`- **권호**: ${volumeIssue}`] : []),
2515
+ `- **수록 논문**: ${issue.papers.length}편`,
2516
+ ];
2517
+ // Counts are per paper and overlap, so they are not summed into a total.
2518
+ // Only keywords shared by several papers say anything about the issue; when
2519
+ // every keyword is unique the summary would just be the alphabetical head of
2520
+ // the list, so it is left out.
2521
+ const keywords = countKeywords(issue.papers)
2522
+ .filter(({ paperCount }) => paperCount > 1)
2523
+ .slice(0, KEYWORD_SUMMARY_LIMIT);
2524
+ if (keywords.length > 0) {
2525
+ lines.push('', '## 여러 논문이 다룬 키워드', '', keywords
2526
+ .map(({ keyword, paperCount }) => `${keyword}(${paperCount}편)`)
2527
+ .join(', '));
2528
+ }
2529
+ lines.push('', '## 수록 논문', '');
2530
+ issue.papers.forEach((paper, index) => {
2531
+ lines.push(`${index + 1}. **[${paper.title.trim()}](${paper.url})**`);
2532
+ const authors = paper.authors.map((name) => name.trim()).filter(Boolean);
2533
+ if (authors.length > 0) {
2534
+ lines.push(` - 저자: ${authors.join(', ')}`);
2535
+ }
2536
+ const keywords = [
2537
+ ...new Set(paper.keywords.map((k) => k.trim()).filter(Boolean)),
2538
+ ];
2539
+ if (keywords.length > 0) {
2540
+ lines.push(` - 키워드: ${keywords.join(', ')}`);
2541
+ }
2542
+ const abstract = paper.abstract?.trim();
2543
+ if (abstract) {
2544
+ lines.push(` - 초록: ${truncate(abstract, ABSTRACT_MAX_LENGTH)}`);
2545
+ }
2546
+ });
2547
+ return lines.join('\n');
2548
+ }
2549
+ const parseJournalIssueList = (html) => {
2550
+ const injected = parseInjectedPayload(html);
2551
+ if (!injected) {
2552
+ return [];
2553
+ }
2554
+ return injected.issues.map((issue) => ({
2555
+ uniqId: issue.externalId,
2556
+ title: formatJournalIssueTitle(issue),
2557
+ date: issue.registeredDate,
2558
+ detailUrl: issue.url,
2559
+ dateType: DateType.REGISTERED,
2560
+ }));
2561
+ };
2562
+ const parseJournalIssueDetail = (html) => {
2563
+ const injected = parseInjectedPayload(html);
2564
+ return {
2565
+ detailContent: injected ? renderJournalIssueContent(injected.issue) : '',
2566
+ hasAttachedFile: false,
2567
+ hasAttachedImage: false,
2568
+ };
2569
+ };
2570
+
2173
2571
  const parseKaahList = (html) => {
2174
2572
  const $ = cheerio.load(html);
2175
2573
  const posts = [];
@@ -2661,31 +3059,6 @@ const parseNrichMajorEventList = (html) => {
2661
3059
  });
2662
3060
  return posts;
2663
3061
  };
2664
- const parseNrichJournalList = (html) => {
2665
- const $ = cheerio.load(html);
2666
- const posts = [];
2667
- const baseUrl = 'https://www.nrich.go.kr';
2668
- $('ul.list-body li').each((index, element) => {
2669
- const titleElement = $(element).find('.col2 a.cont-link');
2670
- const relativeHref = titleElement.attr('href');
2671
- if (!relativeHref) {
2672
- return;
2673
- }
2674
- const fullUrl = new URL(`${relativeHref}`, baseUrl);
2675
- const detailUrl = fullUrl.href;
2676
- const uniqId = fullUrl.searchParams.get('idx') ?? undefined;
2677
- const title = titleElement.text()?.trim() ?? '';
2678
- const date = getDate($(element).find('.col3 .cont-txt').text().trim());
2679
- posts.push({
2680
- uniqId,
2681
- title,
2682
- date,
2683
- detailUrl: cleanUrl(detailUrl),
2684
- dateType: DateType.REGISTERED,
2685
- });
2686
- });
2687
- return posts;
2688
- };
2689
3062
  const parseNrichPortalList = (html) => {
2690
3063
  const $ = cheerio.load(html);
2691
3064
  const posts = [];
@@ -2733,27 +3106,6 @@ const parseNrichMajorEventDetail = (html) => {
2733
3106
  hasAttachedImage: content.find('img').length > 0,
2734
3107
  };
2735
3108
  };
2736
- const parseNrichJournalDetail = (html) => {
2737
- const $ = cheerio.load(html);
2738
- $('script, style').remove();
2739
- const articles = [];
2740
- // 리스트의 각 항목을 순회하면서 논문 정보 추출
2741
- $('ul.list-body li').each((index, element) => {
2742
- const number = $(element).find('.col1 .cont-txt').text().trim();
2743
- const titleElement = $(element).find('.col2 a.cont-link');
2744
- const title = titleElement.text().trim();
2745
- const author = $(element).find('.col3 .cont-txt').text().trim();
2746
- if (title && author) {
2747
- articles.push(`${number}. **${title}**\n 저자: ${author}`);
2748
- }
2749
- });
2750
- const content = articles.length > 0 ? `## 논문 목록\n\n${articles.join('\n\n')}` : '';
2751
- return {
2752
- detailContent: content,
2753
- hasAttachedFile: true,
2754
- hasAttachedImage: false,
2755
- };
2756
- };
2757
3109
  const parseNrichPortalDetail = (html) => {
2758
3110
  const $ = cheerio.load(html);
2759
3111
  const content = $('div.detail_Area2');
@@ -3064,18 +3416,12 @@ function createCrawlingTargetGroups(customFetch) {
3064
3416
  parseDetail: parseNrichMajorEventDetail,
3065
3417
  },
3066
3418
  {
3067
- id: '국립문화유산연구원_학술지_헤리티지',
3068
- name: '국립문화유산연구원 헤리티지:역사와 과학 학술지',
3069
- url: 'https://www.nrich.go.kr/kor/subscriptionDataUsrList.do?menuIdx=1651&gubun=J',
3070
- parseList: parseNrichJournalList,
3071
- parseDetail: parseNrichJournalDetail,
3072
- },
3073
- {
3074
- id: '국립문화유산연구원_학술지_보존과학연구',
3075
- name: '국립문화유산연구원 보존과학연구 학술지',
3076
- url: 'https://www.nrich.go.kr/kor/subscriptionDataUsrList.do?menuIdx=2065&gubun=K',
3077
- parseList: parseNrichJournalList,
3078
- parseDetail: parseNrichJournalDetail,
3419
+ // Served from the application's injected KCI issues, never crawled.
3420
+ id: 'KCI_학술지_신간',
3421
+ name: 'KCI 학술지 신간 권호',
3422
+ url: JOURNAL_ISSUE_LIST_URL,
3423
+ parseList: parseJournalIssueList,
3424
+ parseDetail: parseJournalIssueDetail,
3079
3425
  },
3080
3426
  {
3081
3427
  id: '국가유산지식이음_공지사항',
@@ -4995,6 +5341,16 @@ ${options.heripolabNewsMarkdown}
4995
5341
 
4996
5342
  {{NEWSLETTER_CONTENT}}
4997
5343
 
5344
+ ${options?.journalIssuesMarkdown
5345
+ ? `<div data-research-radar-journal-issues="">${safeMarkdown2Html(options.journalIssuesMarkdown, {
5346
+ window: new JSDOM('').window,
5347
+ linkTargetBlank: true,
5348
+ fixMalformedUrls: true,
5349
+ fixBoldSyntax: true,
5350
+ convertStrikethrough: true,
5351
+ })}</div>`
5352
+ : ''}
5353
+
4998
5354
  <div data-research-radar-closing="">
4999
5355
 
5000
5356
  ${options?.deadlineRemindersMarkdown
@@ -5175,6 +5531,122 @@ function collectNewsletterDeadlines(content, articles, verified) {
5175
5531
  return result;
5176
5532
  }
5177
5533
 
5534
+ /** Heading of the journal issue section. Distinct from any 학술지 heading the model writes. */
5535
+ const JOURNAL_ISSUE_SECTION_HEADING = '📖 새로 나온 학술지';
5536
+ /** Authors listed per paper before the rest are counted. */
5537
+ const AUTHOR_LIMIT = 3;
5538
+ /** Topic labels named in the summary of papers left out of the table. */
5539
+ const TOPIC_LIMIT = 5;
5540
+ /**
5541
+ * Escapes a plain table cell: a `|` would end the cell, a newline the row.
5542
+ * Link labels go through `escapeLabel`, which already covers both.
5543
+ */
5544
+ function cell(value) {
5545
+ return value.replace(/\s+/g, ' ').trim().replace(/\|/g, '\\|');
5546
+ }
5547
+ function formatAuthors(authors) {
5548
+ const names = authors.map((name) => name.trim()).filter(Boolean);
5549
+ if (names.length === 0)
5550
+ return '—';
5551
+ return names.length > AUTHOR_LIMIT
5552
+ ? `${names.slice(0, AUTHOR_LIMIT).join(', ')} 외 ${names.length - AUTHOR_LIMIT}명`
5553
+ : names.join(', ');
5554
+ }
5555
+ function paperLink(paper) {
5556
+ return `[${escapeLabel(paper.title.trim())}](${paper.url})`;
5557
+ }
5558
+ function issueHeading(issue) {
5559
+ const label = [issue.journalName.trim(), formatVolumeIssue(issue)]
5560
+ .filter(Boolean)
5561
+ .join(' ');
5562
+ return `**[${escapeLabel(label)}](${issue.url})** · ${issue.publishedYear}년 ${issue.publishedMonth}월 · 논문 ${issue.papers.length}편`;
5563
+ }
5564
+ function topicSummary(topics) {
5565
+ const named = [
5566
+ ...new Set(topics.filter((topic) => Boolean(topic))),
5567
+ ];
5568
+ if (named.length === 0)
5569
+ return '';
5570
+ return named.slice(0, TOPIC_LIMIT).map(escapeLabel).join(', ');
5571
+ }
5572
+ /**
5573
+ * Renders one issue: the papers its readers would care about as a table, most
5574
+ * interesting first, and the rest as a count with their topics. Table rows plus
5575
+ * that count always equal the paper count.
5576
+ */
5577
+ function renderIssue({ issue, selection }) {
5578
+ const lines = [issueHeading(issue), ''];
5579
+ const featured = selection
5580
+ ? selection.featured
5581
+ : issue.papers.map((_, index) => index);
5582
+ const others = selection?.others ?? [];
5583
+ const topics = topicSummary(others.map(({ topic }) => topic));
5584
+ if (featured.length > 0) {
5585
+ lines.push('| 논문 | 저자 |', '| --- | --- |');
5586
+ for (const index of featured) {
5587
+ const paper = issue.papers[index];
5588
+ lines.push(`| ${paperLink(paper)} | ${cell(formatAuthors(paper.authors))} |`);
5589
+ }
5590
+ if (others.length > 0)
5591
+ lines.push('', topics
5592
+ ? `그 밖에 ${topics} 등을 다룬 논문 ${others.length}편이 함께 실렸습니다.`
5593
+ : `그 밖에 논문 ${others.length}편이 함께 실렸습니다.`);
5594
+ }
5595
+ else {
5596
+ lines.push(topics
5597
+ ? `${topics} 등을 다룬 논문이 실렸습니다.`
5598
+ : '이번 호에는 소개할 만한 논문이 없었습니다.');
5599
+ }
5600
+ return lines.join('\n');
5601
+ }
5602
+ /** Renders the whole section, or '' when there is no issue to show. */
5603
+ function renderJournalIssueSection(entries) {
5604
+ if (entries.length === 0)
5605
+ return '';
5606
+ return [
5607
+ `## ${JOURNAL_ISSUE_SECTION_HEADING}`,
5608
+ '',
5609
+ ...entries.flatMap((entry, index) => index === 0 ? [renderIssue(entry)] : ['', renderIssue(entry)]),
5610
+ ].join('\n');
5611
+ }
5612
+ /**
5613
+ * Headings the section is placed before, in order of preference.
5614
+ *
5615
+ * 사업·입찰 runs last so it does not bury academic news; placing journals after
5616
+ * it would bury them in turn. Without that section the journals go before
5617
+ * 마무리, and without either at the end of the body.
5618
+ */
5619
+ const JOURNAL_ISSUE_SECTION_ANCHORS = [
5620
+ '📑 사업·입찰 공고',
5621
+ '📌 마무리',
5622
+ ];
5623
+ /** Inserts the section Markdown before the first anchor heading found. */
5624
+ function insertJournalIssueMarkdown(content, section) {
5625
+ if (!section)
5626
+ return content;
5627
+ for (const anchor of JOURNAL_ISSUE_SECTION_ANCHORS) {
5628
+ const match = new RegExp(`^##\\s+${anchor.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`, 'm').exec(content);
5629
+ if (match)
5630
+ return `${content.slice(0, match.index)}${section}\n\n${content.slice(match.index)}`;
5631
+ }
5632
+ return `${content.trimEnd()}\n\n${section}`;
5633
+ }
5634
+ /**
5635
+ * Inserts the rendered section before the first anchor `<h2>` found, or before
5636
+ * `fallback` (the closing block) when neither heading is present.
5637
+ */
5638
+ function insertJournalIssueHtml(document, section, fallback) {
5639
+ const headings = [...document.querySelectorAll('h2')];
5640
+ for (const anchor of JOURNAL_ISSUE_SECTION_ANCHORS) {
5641
+ const heading = headings.find((element) => element.textContent?.replace(/\s+/g, ' ').trim() === anchor);
5642
+ if (heading) {
5643
+ heading.before(section);
5644
+ return;
5645
+ }
5646
+ }
5647
+ fallback.before(section);
5648
+ }
5649
+
5178
5650
  /**
5179
5651
  * Content generation provider implementation
5180
5652
  * - LLM-based newsletter content generation
@@ -5186,8 +5658,10 @@ class ContentGenerateProvider {
5186
5658
  newsletterRepository;
5187
5659
  templateOptions;
5188
5660
  selectDeadlineReminders;
5661
+ journalIssues;
5189
5662
  _issueOrder = null;
5190
5663
  deadlineRemindersMarkdown;
5664
+ heldJournalIssues = [];
5191
5665
  model;
5192
5666
  fetchRecentTitles;
5193
5667
  /** HTML template with markers for title and content injection */
@@ -5196,11 +5670,12 @@ class ContentGenerateProvider {
5196
5670
  newsletterBrandName;
5197
5671
  constructor(model, articleRepository, newsletterRepository, templateOptions, brandName,
5198
5672
  /** Chooses displayed reminders; omitted, the first rows by date display. */
5199
- selectDeadlineReminders) {
5673
+ selectDeadlineReminders, journalIssues) {
5200
5674
  this.articleRepository = articleRepository;
5201
5675
  this.newsletterRepository = newsletterRepository;
5202
5676
  this.templateOptions = templateOptions;
5203
5677
  this.selectDeadlineReminders = selectDeadlineReminders;
5678
+ this.journalIssues = journalIssues;
5204
5679
  this.model = model;
5205
5680
  this.deadlineRemindersMarkdown =
5206
5681
  templateOptions?.deadlineRemindersMarkdown?.trim() ?? '';
@@ -5251,7 +5726,29 @@ class ContentGenerateProvider {
5251
5726
  * @returns Articles eligible for inclusion in the newsletter
5252
5727
  */
5253
5728
  async fetchArticleCandidates() {
5254
- return this.articleRepository.findCandidatesForNewsletter();
5729
+ const candidates = await this.articleRepository.findCandidatesForNewsletter();
5730
+ this.heldJournalIssues = [];
5731
+ const journalCandidates = candidates.filter((article) => article.targetUrl === JOURNAL_ISSUE_LIST_URL);
5732
+ if (!this.journalIssues || journalCandidates.length === 0) {
5733
+ return candidates;
5734
+ }
5735
+ // An issue this run cannot load is left to the model, as before; it is
5736
+ // never dropped.
5737
+ let issues;
5738
+ try {
5739
+ issues = await this.journalIssues.load();
5740
+ }
5741
+ catch (error) {
5742
+ this.journalIssues.onUnavailable?.(error instanceof Error ? error.message : String(error));
5743
+ return candidates;
5744
+ }
5745
+ const issuesByUrl = new Map(issues.map((issue) => [issue.url, issue]));
5746
+ this.heldJournalIssues = journalCandidates.flatMap((article) => {
5747
+ const issue = issuesByUrl.get(article.url);
5748
+ return issue ? [{ article, issue }] : [];
5749
+ });
5750
+ const held = new Set(this.heldJournalIssues.map(({ article }) => article));
5751
+ return candidates.filter((article) => !held.has(article));
5255
5752
  }
5256
5753
  /**
5257
5754
  * Save generated newsletter to the repository
@@ -5271,6 +5768,7 @@ class ContentGenerateProvider {
5271
5768
  ? await this.renderDeadlineReminders(reminders, newsletter.date)
5272
5769
  : this.deadlineRemindersMarkdown ||
5273
5770
  (await this.renderDeadlineReminders(reminders, newsletter.date));
5771
+ const journalMarkdown = await this.renderJournalIssues();
5274
5772
  const share = this.templateOptions?.shareNoticeMarkdown ??
5275
5773
  `이 소식이 도움이 되셨다면 동료 연구자에게도 소개해주시면 좋겠습니다. [${escapeLabel(this.newsletterBrandName)} 구독하기](${this.subscribePageUrl})`;
5276
5774
  // Render only the closing block with the original stylesheet. Keep core's
@@ -5279,22 +5777,46 @@ class ContentGenerateProvider {
5279
5777
  ...this.templateOptions,
5280
5778
  deadlineRemindersMarkdown: markdown,
5281
5779
  shareNoticeMarkdown: share,
5780
+ journalIssuesMarkdown: journalMarkdown,
5282
5781
  }))).window.document;
5283
5782
  const dom = new JSDOM(newsletter.htmlBody);
5284
5783
  const document = dom.window.document;
5285
5784
  const closing = document.querySelector('[data-research-radar-closing]');
5286
5785
  if (!closing)
5287
5786
  throw new Error('Newsletter closing block not found');
5787
+ const journalSection = closingDocument.querySelector('[data-research-radar-journal-issues]');
5788
+ if (journalSection) {
5789
+ insertJournalIssueHtml(document, document.importNode(journalSection, true), closing);
5790
+ }
5288
5791
  closing.outerHTML = closingDocument.querySelector('[data-research-radar-closing]').outerHTML;
5792
+ // Core hands back only the candidates the model saw; the held-aside
5793
+ // journal articles are part of this issue too.
5794
+ const usedIds = new Set(usedArticles.map((article) => article.id));
5289
5795
  return this.newsletterRepository.saveNewsletter({
5290
5796
  ...input,
5797
+ usedArticles: [
5798
+ ...usedArticles,
5799
+ ...this.heldJournalIssues
5800
+ .map(({ article }) => article)
5801
+ .filter((article) => !usedIds.has(article.id)),
5802
+ ],
5291
5803
  newsletter: {
5292
5804
  ...newsletter,
5293
- content: `${newsletter.content}${markdown ? `\n\n<!-- research-radar-deadline-reminders -->\n${markdown}` : ''}${share ? `\n\n<!-- research-radar-share-notice -->\n${share}` : ''}`,
5805
+ content: `${insertJournalIssueMarkdown(newsletter.content, journalMarkdown)}${markdown ? `\n\n<!-- research-radar-deadline-reminders -->\n${markdown}` : ''}${share ? `\n\n<!-- research-radar-share-notice -->\n${share}` : ''}`,
5294
5806
  htmlBody: dom.serialize(),
5295
5807
  },
5296
5808
  });
5297
5809
  }
5810
+ async renderJournalIssues() {
5811
+ if (this.heldJournalIssues.length === 0)
5812
+ return '';
5813
+ const select = this.journalIssues?.select;
5814
+ const entries = await Promise.all(this.heldJournalIssues.map(async ({ issue }) => ({
5815
+ issue,
5816
+ selection: select ? await select(issue) : null,
5817
+ })));
5818
+ return renderJournalIssueSection(entries);
5819
+ }
5298
5820
  async renderDeadlineReminders(reminders, publicationDate) {
5299
5821
  if (!this.selectDeadlineReminders)
5300
5822
  return renderVerifiedDeadlineReminders(reminders, publicationDate);
@@ -5548,7 +6070,7 @@ function createRobotsAwareFetch(baseFetch = fetch, options = {}) {
5548
6070
  }
5549
6071
 
5550
6072
  /** Shared network/adapters path for daily crawling and single-source refresh. */
5551
- function createResearchRadarFetch({ customFetch, excavationReportSource, logger, publicDataApiKey, bidTriage, refreshG2bDetails, } = {}) {
6073
+ function createResearchRadarFetch({ customFetch, excavationReportSource, journalIssueSource, logger, publicDataApiKey, bidTriage, refreshG2bDetails, } = {}) {
5552
6074
  // robots.txt is checked first, so a disallowed request is never sent — not
5553
6075
  // even through a proxy. The injected and KRAS adapters sit inside it: their
5554
6076
  // requests either bypass the network entirely or are rewritten to a URL
@@ -5596,9 +6118,13 @@ function createResearchRadarFetch({ customFetch, excavationReportSource, logger,
5596
6118
  // When the application supplies excavation reports, that board is served
5597
6119
  // from the injected source and never requested over the network. Every
5598
6120
  // other target keeps going through the same fetch as before.
5599
- return excavationReportSource
6121
+ const withExcavationReports = excavationReportSource
5600
6122
  ? createExcavationReportFetch(withPublicJobs, excavationReportSource)
5601
6123
  : withPublicJobs;
6124
+ // Journal issues have no live board to fall back to, so this adapter is
6125
+ // always installed: without a source the target is an empty list and its
6126
+ // URL is never requested.
6127
+ return createJournalIssueFetch(withExcavationReports, journalIssueSource);
5602
6128
  }
5603
6129
 
5604
6130
  /**
@@ -5615,11 +6141,12 @@ class CrawlingProvider {
5615
6141
  customFetch;
5616
6142
  /** Crawling target groups configuration */
5617
6143
  crawlingTargetGroups;
5618
- constructor(articleRepository, customFetch, excavationReportSource, logger, publicDataApiKey, bidTriage) {
6144
+ constructor(articleRepository, customFetch, excavationReportSource, logger, publicDataApiKey, bidTriage, journalIssueSource) {
5619
6145
  this.articleRepository = articleRepository;
5620
6146
  this.customFetch = createResearchRadarFetch({
5621
6147
  customFetch,
5622
6148
  excavationReportSource,
6149
+ journalIssueSource,
5623
6150
  logger,
5624
6151
  publicDataApiKey,
5625
6152
  bidTriage,
@@ -5738,6 +6265,10 @@ function createNewsletterGenerator(dependencies) {
5738
6265
  };
5739
6266
  const dateService = new DateService(dependencies.publishDate);
5740
6267
  const taskService = new TaskService(dependencies.taskRepository);
6268
+ // One source call serves both the crawl and the journal tables at save time.
6269
+ const loadJournalIssues = dependencies.journalIssueSource
6270
+ ? createJournalIssueLoader(dependencies.journalIssueSource)
6271
+ : undefined;
5741
6272
  const crawlingProvider = new CrawlingProvider(dependencies.articleRepository, dependencies.customFetch, dependencies.excavationReportSource, dependencies.logger, dependencies.publicDataApiKey,
5742
6273
  // 나라장터 publishes about 1,500 notices per 48-hour window, so which ones
5743
6274
  // reach per-article scoring is decided here, 100 titles per request. The
@@ -5750,7 +6281,7 @@ function createNewsletterGenerator(dependencies) {
5750
6281
  data: { reason, batchSize },
5751
6282
  });
5752
6283
  },
5753
- }));
6284
+ }), loadJournalIssues);
5754
6285
  const analysisProvider = new AnalysisProvider({
5755
6286
  classifyTags: resolveModel('classifyTags'),
5756
6287
  analyzeImages: resolveModel('analyzeImages'),
@@ -5804,7 +6335,29 @@ function createNewsletterGenerator(dependencies) {
5804
6335
  data,
5805
6336
  });
5806
6337
  },
5807
- }));
6338
+ }), loadJournalIssues && {
6339
+ load: loadJournalIssues,
6340
+ // Choosing papers is a relevance judgement for the readers, like
6341
+ // importance, so it reuses that model.
6342
+ select: createJournalPaperSelector({
6343
+ model: resolveModel('determineImportance'),
6344
+ audience: templateOptions?.isKrasNewsletter
6345
+ ? '한국고고학회 회원(고고학 연구자, 발굴·조사기관 종사자, 관련 전공 학생)'
6346
+ : '문화유산 연구자와 실무자(고고학, 보존과학, 학예, 문화유산 행정)',
6347
+ onFallback: (reason, issue) => {
6348
+ dependencies.logger?.info({
6349
+ event: 'newsletter.journals.selection.fallback',
6350
+ data: { reason, issueUrl: issue.url },
6351
+ });
6352
+ },
6353
+ }),
6354
+ onUnavailable: (reason) => {
6355
+ dependencies.logger?.error({
6356
+ event: 'newsletter.journals.load.failed',
6357
+ data: { reason },
6358
+ });
6359
+ },
6360
+ });
5808
6361
  return new GenerateNewsletter({
5809
6362
  contentOptions: resolvedContentOptions,
5810
6363
  promptProvider: dependencies.promptProvider ?? researchRadarPromptProvider,
@@ -6329,5 +6882,5 @@ async function refreshResearchRadarDeadlines(config) {
6329
6882
  }
6330
6883
  }
6331
6884
 
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 };
6885
+ export { AnalysisProvider, ContentGenerateProvider, CrawlingProvider, DEADLINE_REMINDER_LEAD_DAYS, DEADLINE_REMINDER_LIMIT, DateService, JOURNAL_ISSUE_LIST_URL, TaskService, contentOptions, createCrawlingTargetGroups, createDeadlineReminderSelector, extractResearchRadarDeadlines, fetchResearchRadarDeadlineSource, generateNewsletter, generateWelcomeHTML, getSourceList, llmConfig, maximumImportanceScoreByDomain, newsletterConfig, refreshResearchRadarDeadlines, renderVerifiedDeadlineReminders, researchRadarPromptProvider, robotsExemptOrigins };
6333
6886
  //# 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.1.0",
5
+ "version": "6.2.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",