@llm-newsletter-kit/core 1.1.4 → 1.1.6

package/dist/index.cjs

@@ -838,8 +838,14 @@ class AnalysisChain extends Chain {
     }
 }
 
+function preprocessBoldSyntax(markdown) {
+    // Convert **text** to <strong>text</strong> before marked parsing
+    // This fixes issues where marked doesn't properly handle bold syntax with parentheses
+    return markdown.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
+}
 function markdownToHtml(markdown) {
-    const html = marked.marked.parse(markdown);
+    const preprocessed = preprocessBoldSyntax(markdown);
+    const html = marked.marked.parse(preprocessed);
     const window = new jsdom.JSDOM('').window;
     const purify = DOMPurify(window);
     const sanitized = purify.sanitize(html);
@@ -849,22 +855,9 @@ function markdownToHtml(markdown) {
     return correctUnconvertedBoldSyntax(withDelReplaced);
 }
 function addTargetBlankToAnchors(htmlString) {
-    // Regular expression to find '<a>' tags
-    // This regex matches '<a>' tags that contain 'href' attribute and optionally other attributes
-    // Excludes 'target="[^"]*"' to check if target attribute already exists
-    const regex = /<a(\s+[^>]*?)?(?<!target="[^"]*")>/gi;
-    // Use regex to find '<a>' tags and add 'target="_blank"'
-    return htmlString.replace(regex, (_match, attributes) => {
-        // Handle undefined attributes as empty string
-        const currentAttributes = attributes || '';
-        // Double check if target attribute exists (safety check for regex limitations)
-        if (currentAttributes.includes('target=')) {
-            return `<a${currentAttributes}>`; // If target attribute exists, return without modification
-        }
-        else {
-            // Add target="_blank" attribute
-            return `<a${currentAttributes} target="_blank">`;
-        }
+    // DOMPurify removes target attributes, so we can safely add target="_blank" to all anchors
+    return htmlString.replace(/<a\s+([^>]*)>/gi, (_match, attributes) => {
+        return `<a ${attributes} target="_blank">`;
     });
 }
 function replaceDelTagsWithTilde(htmlString) {
@@ -877,19 +870,20 @@ function correctUnconvertedBoldSyntax(htmlString) {
     return htmlString.replace(/\*\*([^*]+)\*\*/g, '<b>$1</b>');
 }
 function correctMalformedUrls(htmlString) {
-    // Pattern matches anchors with `)` followed by URL-encoded characters
+    // Pattern matches anchors with `)` followed by optional closing markup (</b> or **) and URL-encoded characters
     // Capture groups:
     // 1: attributes before href
     // 2: URL base (before `)`)
-    // 3: URL-encoded part (starts with %)
-    // 4: attributes after href
-    // 5: link text base (before `)`)
-    // 6: decoded text after `)` in link text
-    const regex = /<a\s+([^>]*?)href="([^"]*?)\)(%[0-9A-Fa-f]{2}[^"]*?)"([^>]*?)>([^<]*?)\)([^<]*?)<\/a>/g;
-    return htmlString.replace(regex, (_match, beforeHref, urlBase, _encodedPart, afterHref, textBase, decodedTextInLink) => {
-        // The decoded text is already in the link text (decodedTextInLink)
-        // We just need to move it outside the anchor along with the `)`
-        return `<a ${beforeHref}href="${urlBase}"${afterHref}>${textBase}</a>)${decodedTextInLink}`;
+    // 3: closing markup (</b> or ** or empty)
+    // 4: URL-encoded part (starts with %)
+    // 5: attributes after href
+    // 6: link text base (before `)`)
+    // 7: text after `)` in link text (may include **)
+    const regex = /<a\s+([^>]*?)href="([^"]*?)\)((?:<\/b>|\*\*)?)(%[0-9A-Fa-f]{2}[^"]*?)"([^>]*?)>([^<]*?)\)((?:\*\*)?[^<]*?)<\/a>/g;
+    return htmlString.replace(regex, (_match, beforeHref, urlBase, closingMarkup, _encodedPart, afterHref, textBase, textAfterClosingParen) => {
+        // Remove leading ** from textAfterClosingParen since it's already captured as closingMarkup (</b>)
+        const cleanedText = textAfterClosingParen.replace(/^\*\*/, '');
+        return `<a ${beforeHref}href="${urlBase}"${afterHref}>${textBase}</a>${closingMarkup})${cleanedText}`;
     });
 }
 
@@ -1397,6 +1391,7 @@ async function getHtmlFromUrl(logger, url, referer = 'https://www.google.com/')
     throw lastError;
 }
 
+const toErrorMessage = (error) => error instanceof Error ? error.message : String(error);
 class CrawlingChain extends Chain {
     constructor(config) {
         const provider = config.provider;
@@ -1426,17 +1421,15 @@ class CrawlingChain extends Chain {
             target: ({ target }) => target,
         })
             .pipe({
-            detailPagesHtmlWithPipelineId: ({ target, list }) => this.fetchDetailPagesHtml(target, list),
+            detailFetchResult: ({ target, list }) => this.fetchDetailPagesHtml(target, list),
             target: ({ target }) => target,
-            list: ({ list }) => list,
         })
             .pipe({
-            parsedDetails: ({ target, detailPagesHtmlWithPipelineId }) => this.parseDetailPagesHtml(target, detailPagesHtmlWithPipelineId),
+            detailParseResult: ({ target, detailFetchResult }) => this.parseDetailPagesHtml(target, detailFetchResult.list, detailFetchResult.detailPagesHtmlWithPipelineId),
             target: ({ target }) => target,
-            list: ({ list }) => list,
         })
             .pipe({
-            processedArticles: ({ target, list, parsedDetails }) => this.mergeParsedArticles(target, list, parsedDetails),
+            processedArticles: ({ target, detailParseResult }) => this.mergeParsedArticles(target, detailParseResult.list, detailParseResult.parsedDetails),
             target: ({ target }) => target,
         })
             .pipe({
@@ -1464,7 +1457,21 @@ class CrawlingChain extends Chain {
             level: 'debug',
             startFields: { target: this.describeTarget(target) },
         }, async () => {
-            return await getHtmlFromUrl(this.logger, target.url);
+            try {
+                return await getHtmlFromUrl(this.logger, target.url);
+            }
+            catch (error) {
+                this.logger.error({
+                    event: 'crawl.list.fetch.failed',
+                    taskId: this.taskId,
+                    data: {
+                        target: this.describeTarget(target),
+                        url: target.url,
+                        error: toErrorMessage(error),
+                    },
+                });
+                return '';
+            }
         });
     }
     async parseListPageHtml(target, listPageHtml) {
@@ -1477,10 +1484,26 @@ class CrawlingChain extends Chain {
             },
             doneFields: (items) => ({ count: items.length }),
         }, async () => {
-            return (await target.parseList(listPageHtml)).map((item) => ({
-                ...item,
-                pipelineId: node_crypto.randomUUID(),
-            }));
+            if (listPageHtml.length === 0) {
+                return [];
+            }
+            try {
+                return (await target.parseList(listPageHtml)).map((item) => ({
+                    ...item,
+                    pipelineId: node_crypto.randomUUID(),
+                }));
+            }
+            catch (error) {
+                this.logger.error({
+                    event: 'crawl.list.parse.failed',
+                    taskId: this.taskId,
+                    data: {
+                        target: this.describeTarget(target),
+                        error: toErrorMessage(error),
+                    },
+                });
+                return [];
+            }
         });
     }
     async dedupeListItems(target, parsedList) {
@@ -1509,16 +1532,44 @@ class CrawlingChain extends Chain {
                 target: this.describeTarget(target),
                 count: list.length,
             },
-            doneFields: (htmlList) => ({ count: htmlList.length }),
+            doneFields: (result) => ({
+                successCount: result.detailPagesHtmlWithPipelineId.length,
+                failedCount: result.failedCount,
+            }),
         }, async () => {
-            const htmlList = await Promise.all(list.map((data) => getHtmlFromUrl(this.logger, data.detailUrl)));
-            return htmlList.map((html, index) => ({
-                pipelineId: list[index].pipelineId,
-                html,
-            }));
+            const settled = await Promise.allSettled(list.map((data) => getHtmlFromUrl(this.logger, data.detailUrl)));
+            const detailPagesHtmlWithPipelineId = [];
+            const successList = [];
+            let failedCount = 0;
+            settled.forEach((result, index) => {
+                const item = list[index];
+                if (result.status === 'fulfilled') {
+                    detailPagesHtmlWithPipelineId.push({
+                        pipelineId: item.pipelineId,
+                        html: result.value,
+                    });
+                    successList.push(item);
+                    return;
+                }
+                failedCount += 1;
+                this.logger.error({
+                    event: 'crawl.detail.fetch.failed',
+                    taskId: this.taskId,
+                    data: {
+                        target: this.describeTarget(target),
+                        detailUrl: item.detailUrl,
+                        error: toErrorMessage(result.reason),
+                    },
+                });
+            });
+            return {
+                list: successList,
+                detailPagesHtmlWithPipelineId,
+                failedCount,
+            };
         });
     }
-    async parseDetailPagesHtml(target, detailPagesHtmlWithPipelineId) {
+    async parseDetailPagesHtml(target, list, detailPagesHtmlWithPipelineId) {
         return this.executeWithLogging({
             event: 'crawl.detail.parse',
             level: 'debug',
@@ -1526,13 +1577,46 @@ class CrawlingChain extends Chain {
                 target: this.describeTarget(target),
                 count: detailPagesHtmlWithPipelineId.length,
             },
-            doneFields: (details) => ({ count: details.length }),
+            doneFields: (result) => ({
+                successCount: result.parsedDetails.length,
+                failedCount: result.failedCount,
+            }),
         }, async () => {
-            const detail = await Promise.all(detailPagesHtmlWithPipelineId.map(({ html }) => target.parseDetail(html)));
-            return detail.map((detail, index) => ({
-                pipelineId: detailPagesHtmlWithPipelineId[index].pipelineId,
-                ...detail,
-            }));
+            const listItemMap = new Map(list.map((item) => [item.pipelineId, item]));
+            const settled = await Promise.allSettled(detailPagesHtmlWithPipelineId.map(({ html }) => target.parseDetail(html)));
+            const parsedDetails = [];
+            const successList = [];
+            let failedCount = 0;
+            settled.forEach((result, index) => {
+                const htmlItem = detailPagesHtmlWithPipelineId[index];
+                const listItem = listItemMap.get(htmlItem.pipelineId);
+                if (result.status === 'fulfilled' && listItem) {
+                    parsedDetails.push({
+                        pipelineId: htmlItem.pipelineId,
+                        ...result.value,
+                    });
+                    successList.push(listItem);
+                    return;
+                }
+                failedCount += 1;
+                this.logger.error({
+                    event: 'crawl.detail.parse.failed',
+                    taskId: this.taskId,
+                    data: {
+                        target: this.describeTarget(target),
+                        detailUrl: listItem?.detailUrl,
+                        pipelineId: htmlItem.pipelineId,
+                        error: result.status === 'rejected'
+                            ? toErrorMessage(result.reason)
+                            : 'Missing list item for parsed detail',
+                    },
+                });
+            });
+            return {
+                list: successList,
+                parsedDetails,
+                failedCount,
+            };
         });
     }
     // Although this is a synchronous method, using async wrapping to maintain consistency with the executeWithLogging interface

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.js

@@ -836,8 +836,14 @@ class AnalysisChain extends Chain {
     }
 }
 
+function preprocessBoldSyntax(markdown) {
+    // Convert **text** to <strong>text</strong> before marked parsing
+    // This fixes issues where marked doesn't properly handle bold syntax with parentheses
+    return markdown.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
+}
 function markdownToHtml(markdown) {
-    const html = marked.parse(markdown);
+    const preprocessed = preprocessBoldSyntax(markdown);
+    const html = marked.parse(preprocessed);
     const window = new JSDOM('').window;
     const purify = DOMPurify(window);
     const sanitized = purify.sanitize(html);
@@ -847,22 +853,9 @@ function markdownToHtml(markdown) {
     return correctUnconvertedBoldSyntax(withDelReplaced);
 }
 function addTargetBlankToAnchors(htmlString) {
-    // Regular expression to find '<a>' tags
-    // This regex matches '<a>' tags that contain 'href' attribute and optionally other attributes
-    // Excludes 'target="[^"]*"' to check if target attribute already exists
-    const regex = /<a(\s+[^>]*?)?(?<!target="[^"]*")>/gi;
-    // Use regex to find '<a>' tags and add 'target="_blank"'
-    return htmlString.replace(regex, (_match, attributes) => {
-        // Handle undefined attributes as empty string
-        const currentAttributes = attributes || '';
-        // Double check if target attribute exists (safety check for regex limitations)
-        if (currentAttributes.includes('target=')) {
-            return `<a${currentAttributes}>`; // If target attribute exists, return without modification
-        }
-        else {
-            // Add target="_blank" attribute
-            return `<a${currentAttributes} target="_blank">`;
-        }
+    // DOMPurify removes target attributes, so we can safely add target="_blank" to all anchors
+    return htmlString.replace(/<a\s+([^>]*)>/gi, (_match, attributes) => {
+        return `<a ${attributes} target="_blank">`;
     });
 }
 function replaceDelTagsWithTilde(htmlString) {
@@ -875,19 +868,20 @@ function correctUnconvertedBoldSyntax(htmlString) {
     return htmlString.replace(/\*\*([^*]+)\*\*/g, '<b>$1</b>');
 }
 function correctMalformedUrls(htmlString) {
-    // Pattern matches anchors with `)` followed by URL-encoded characters
+    // Pattern matches anchors with `)` followed by optional closing markup (</b> or **) and URL-encoded characters
     // Capture groups:
     // 1: attributes before href
     // 2: URL base (before `)`)
-    // 3: URL-encoded part (starts with %)
-    // 4: attributes after href
-    // 5: link text base (before `)`)
-    // 6: decoded text after `)` in link text
-    const regex = /<a\s+([^>]*?)href="([^"]*?)\)(%[0-9A-Fa-f]{2}[^"]*?)"([^>]*?)>([^<]*?)\)([^<]*?)<\/a>/g;
-    return htmlString.replace(regex, (_match, beforeHref, urlBase, _encodedPart, afterHref, textBase, decodedTextInLink) => {
-        // The decoded text is already in the link text (decodedTextInLink)
-        // We just need to move it outside the anchor along with the `)`
-        return `<a ${beforeHref}href="${urlBase}"${afterHref}>${textBase}</a>)${decodedTextInLink}`;
+    // 3: closing markup (</b> or ** or empty)
+    // 4: URL-encoded part (starts with %)
+    // 5: attributes after href
+    // 6: link text base (before `)`)
+    // 7: text after `)` in link text (may include **)
+    const regex = /<a\s+([^>]*?)href="([^"]*?)\)((?:<\/b>|\*\*)?)(%[0-9A-Fa-f]{2}[^"]*?)"([^>]*?)>([^<]*?)\)((?:\*\*)?[^<]*?)<\/a>/g;
+    return htmlString.replace(regex, (_match, beforeHref, urlBase, closingMarkup, _encodedPart, afterHref, textBase, textAfterClosingParen) => {
+        // Remove leading ** from textAfterClosingParen since it's already captured as closingMarkup (</b>)
+        const cleanedText = textAfterClosingParen.replace(/^\*\*/, '');
+        return `<a ${beforeHref}href="${urlBase}"${afterHref}>${textBase}</a>${closingMarkup})${cleanedText}`;
     });
 }
 
@@ -1395,6 +1389,7 @@ async function getHtmlFromUrl(logger, url, referer = 'https://www.google.com/')
     throw lastError;
 }
 
+const toErrorMessage = (error) => error instanceof Error ? error.message : String(error);
 class CrawlingChain extends Chain {
     constructor(config) {
         const provider = config.provider;
@@ -1424,17 +1419,15 @@ class CrawlingChain extends Chain {
             target: ({ target }) => target,
         })
             .pipe({
-            detailPagesHtmlWithPipelineId: ({ target, list }) => this.fetchDetailPagesHtml(target, list),
+            detailFetchResult: ({ target, list }) => this.fetchDetailPagesHtml(target, list),
             target: ({ target }) => target,
-            list: ({ list }) => list,
         })
             .pipe({
-            parsedDetails: ({ target, detailPagesHtmlWithPipelineId }) => this.parseDetailPagesHtml(target, detailPagesHtmlWithPipelineId),
+            detailParseResult: ({ target, detailFetchResult }) => this.parseDetailPagesHtml(target, detailFetchResult.list, detailFetchResult.detailPagesHtmlWithPipelineId),
             target: ({ target }) => target,
-            list: ({ list }) => list,
         })
             .pipe({
-            processedArticles: ({ target, list, parsedDetails }) => this.mergeParsedArticles(target, list, parsedDetails),
+            processedArticles: ({ target, detailParseResult }) => this.mergeParsedArticles(target, detailParseResult.list, detailParseResult.parsedDetails),
             target: ({ target }) => target,
         })
             .pipe({
@@ -1462,7 +1455,21 @@ class CrawlingChain extends Chain {
             level: 'debug',
             startFields: { target: this.describeTarget(target) },
         }, async () => {
-            return await getHtmlFromUrl(this.logger, target.url);
+            try {
+                return await getHtmlFromUrl(this.logger, target.url);
+            }
+            catch (error) {
+                this.logger.error({
+                    event: 'crawl.list.fetch.failed',
+                    taskId: this.taskId,
+                    data: {
+                        target: this.describeTarget(target),
+                        url: target.url,
+                        error: toErrorMessage(error),
+                    },
+                });
+                return '';
+            }
         });
     }
     async parseListPageHtml(target, listPageHtml) {
@@ -1475,10 +1482,26 @@ class CrawlingChain extends Chain {
             },
             doneFields: (items) => ({ count: items.length }),
         }, async () => {
-            return (await target.parseList(listPageHtml)).map((item) => ({
-                ...item,
-                pipelineId: randomUUID(),
-            }));
+            if (listPageHtml.length === 0) {
+                return [];
+            }
+            try {
+                return (await target.parseList(listPageHtml)).map((item) => ({
+                    ...item,
+                    pipelineId: randomUUID(),
+                }));
+            }
+            catch (error) {
+                this.logger.error({
+                    event: 'crawl.list.parse.failed',
+                    taskId: this.taskId,
+                    data: {
+                        target: this.describeTarget(target),
+                        error: toErrorMessage(error),
+                    },
+                });
+                return [];
+            }
         });
     }
     async dedupeListItems(target, parsedList) {
@@ -1507,16 +1530,44 @@ class CrawlingChain extends Chain {
                 target: this.describeTarget(target),
                 count: list.length,
             },
-            doneFields: (htmlList) => ({ count: htmlList.length }),
+            doneFields: (result) => ({
+                successCount: result.detailPagesHtmlWithPipelineId.length,
+                failedCount: result.failedCount,
+            }),
         }, async () => {
-            const htmlList = await Promise.all(list.map((data) => getHtmlFromUrl(this.logger, data.detailUrl)));
-            return htmlList.map((html, index) => ({
-                pipelineId: list[index].pipelineId,
-                html,
-            }));
+            const settled = await Promise.allSettled(list.map((data) => getHtmlFromUrl(this.logger, data.detailUrl)));
+            const detailPagesHtmlWithPipelineId = [];
+            const successList = [];
+            let failedCount = 0;
+            settled.forEach((result, index) => {
+                const item = list[index];
+                if (result.status === 'fulfilled') {
+                    detailPagesHtmlWithPipelineId.push({
+                        pipelineId: item.pipelineId,
+                        html: result.value,
+                    });
+                    successList.push(item);
+                    return;
+                }
+                failedCount += 1;
+                this.logger.error({
+                    event: 'crawl.detail.fetch.failed',
+                    taskId: this.taskId,
+                    data: {
+                        target: this.describeTarget(target),
+                        detailUrl: item.detailUrl,
+                        error: toErrorMessage(result.reason),
+                    },
+                });
+            });
+            return {
+                list: successList,
+                detailPagesHtmlWithPipelineId,
+                failedCount,
+            };
         });
     }
-    async parseDetailPagesHtml(target, detailPagesHtmlWithPipelineId) {
+    async parseDetailPagesHtml(target, list, detailPagesHtmlWithPipelineId) {
         return this.executeWithLogging({
             event: 'crawl.detail.parse',
             level: 'debug',
@@ -1524,13 +1575,46 @@ class CrawlingChain extends Chain {
                 target: this.describeTarget(target),
                 count: detailPagesHtmlWithPipelineId.length,
             },
-            doneFields: (details) => ({ count: details.length }),
+            doneFields: (result) => ({
+                successCount: result.parsedDetails.length,
+                failedCount: result.failedCount,
+            }),
         }, async () => {
-            const detail = await Promise.all(detailPagesHtmlWithPipelineId.map(({ html }) => target.parseDetail(html)));
-            return detail.map((detail, index) => ({
-                pipelineId: detailPagesHtmlWithPipelineId[index].pipelineId,
-                ...detail,
-            }));
+            const listItemMap = new Map(list.map((item) => [item.pipelineId, item]));
+            const settled = await Promise.allSettled(detailPagesHtmlWithPipelineId.map(({ html }) => target.parseDetail(html)));
+            const parsedDetails = [];
+            const successList = [];
+            let failedCount = 0;
+            settled.forEach((result, index) => {
+                const htmlItem = detailPagesHtmlWithPipelineId[index];
+                const listItem = listItemMap.get(htmlItem.pipelineId);
+                if (result.status === 'fulfilled' && listItem) {
+                    parsedDetails.push({
+                        pipelineId: htmlItem.pipelineId,
+                        ...result.value,
+                    });
+                    successList.push(listItem);
+                    return;
+                }
+                failedCount += 1;
+                this.logger.error({
+                    event: 'crawl.detail.parse.failed',
+                    taskId: this.taskId,
+                    data: {
+                        target: this.describeTarget(target),
+                        detailUrl: listItem?.detailUrl,
+                        pipelineId: htmlItem.pipelineId,
+                        error: result.status === 'rejected'
+                            ? toErrorMessage(result.reason)
+                            : 'Missing list item for parsed detail',
+                    },
+                });
+            });
+            return {
+                list: successList,
+                parsedDetails,
+                failedCount,
+            };
         });
     }
     // Although this is a synchronous method, using async wrapping to maintain consistency with the executeWithLogging interface

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@llm-newsletter-kit/core",
   "private": false,
   "type": "module",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "An extensible framework to automate your entire newsletter workflow. Handles data collection, LLM-based content analysis, and email generation, letting you focus on your unique domain logic.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -46,8 +46,8 @@
   "author": "kimhongyeon",
   "license": "Apache-2.0",
   "dependencies": {
-    "@langchain/core": "^1.1.18",
-    "ai": "^6.0.66",
+    "@langchain/core": "^1.1.19",
+    "ai": "^6.0.69",
     "dompurify": "^3.3.1",
     "es-toolkit": "^1.44.0",
     "jsdom": "^27.4.0",
@@ -59,7 +59,7 @@
     "@eslint/js": "^9.39.2",
     "@trivago/prettier-plugin-sort-imports": "^6.0.2",
     "@types/jsdom": "^27.0.0",
-    "@types/node": "^25.1.0",
+    "@types/node": "^25.2.0",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/expect": "^3.2.4",
     "eslint": "^9.39.2",