n8n-nodes-seo-scanner 1.2.32 → 1.2.34

package/dist/SeoScanner.node.js

@@ -85,6 +85,97 @@ function readNullableNumber(value) {
     const numberValue = Number(value);
     return Number.isFinite(numberValue) ? numberValue : undefined;
 }
+function readStringArray(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => readStringArray(item) || []);
+    }
+    if (typeof value !== 'string')
+        return [];
+    const trimmed = value.trim();
+    if (!trimmed)
+        return [];
+    if (trimmed.startsWith('[')) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed))
+                return readStringArray(parsed) || [];
+        }
+        catch {
+        }
+    }
+    return trimmed.split(/\r?\n/).map((item) => item.trim()).filter(Boolean);
+}
+function uniqueStrings(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const key = value.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(value);
+    }
+    return result;
+}
+function stripWww(hostname) {
+    return hostname.toLowerCase().replace(/^www\./, '');
+}
+function sameCrawlDomain(url1, url2) {
+    try {
+        return stripWww(new URL(url1).hostname) === stripWww(new URL(url2).hostname);
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeCrawlAbsoluteUrl(value) {
+    if (!/^https?:\/\//i.test(value))
+        return '';
+    try {
+        const url = new URL(value);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            return '';
+        url.hash = '';
+        url.searchParams.sort();
+        return url.href.replace(/\/$/, '');
+    }
+    catch {
+        return '';
+    }
+}
+function urlContainsPattern(url, pattern) {
+    const normalizedUrl = url.toLowerCase();
+    const normalizedPattern = pattern.toLowerCase();
+    try {
+        const parsed = new URL(url);
+        const pathAndSearch = `${parsed.pathname}${parsed.search}`.toLowerCase();
+        return normalizedUrl.includes(normalizedPattern) || pathAndSearch.includes(normalizedPattern);
+    }
+    catch {
+        return normalizedUrl.includes(normalizedPattern);
+    }
+}
+function normalizePlanInternalLimit(value) {
+    if (value === null)
+        return null;
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return undefined;
+    return Math.max(1, Math.round(value));
+}
+function planInternalLimitError(limit, planName) {
+    if (planName?.toLowerCase() === 'max' && limit === 100) {
+        return 'Tu plan Max permite escanear como máximo 100 páginas internas por escaneo. Para escanear más páginas, puedes usar el escaneo por API o contactar con soporte.';
+    }
+    return `Tu plan permite escanear como máximo ${limit} páginas internas por escaneo.`;
+}
+function requiredSlotsLimitError(availableRequiredSlots) {
+    if (availableRequiredSlots <= 0) {
+        return 'Ya has usado todo el límite de páginas internas de tu plan. Baja el número de páginas internas a escanear para poder añadir páginas obligatorias.';
+    }
+    return `Con la configuración actual solo puedes añadir ${availableRequiredSlots} páginas obligatorias. Baja el número de páginas internas a escanear o mejora tu plan.`;
+}
 function readHeader(headers, name) {
     const direct = readString(headers[name]);
     if (direct)
@@ -228,8 +319,17 @@ function getIncomingWebhookPayload(input) {
             readBearerToken(authorization),
         apiToken: readString(source.apiToken) ||
             readHeader(headers, 'x-api-token'),
-        scanInternalLinks: readBoolean(source.allsite) ?? readBoolean(source.scanInternalLinks),
-        maxInternalUrls: readNumber(source.maxInternalUrls),
+        scanFullSite: readBoolean(source.scanFullSite),
+        scanInternalLinks: readBoolean(source.scanFullSite) ?? readBoolean(source.allsite) ?? readBoolean(source.scanInternalLinks),
+        maxUrls: readNumber(source.maxUrls),
+        maxInternalUrls: readNumber(source.maxInternalUrls) ?? readNumber(source.maxUrls),
+        requiredUrls: readStringArray(source.requiredUrls),
+        excludedPatterns: readStringArray(source.excludedPatterns),
+        ignoredUrls: readStringArray(source.ignoredUrls),
+        planName: readString(source.planName) || readString(source.webPlan) || readString(source.apiPlan),
+        planInternalPageLimit: readNullableNumber(source.planInternalPageLimit) ??
+            readNullableNumber(source.webInternalPageLimit) ??
+            readNullableNumber(source.maxWebScanUrls),
         scanLimitSource: readString(source.scanLimitSource) === 'api' ? 'api' : undefined,
         apiPlan: readString(source.apiPlan),
         apiInternalPageLimit: readNullableNumber(source.apiInternalPageLimit),
@@ -287,6 +387,24 @@ class SeoScanner {
                     description: 'Número máximo de páginas internas a analizar. El rastreo sigue enlaces descubiertos en cada página y usa el sitemap como semilla si existe.',
                     displayOptions: { show: { scanInternalLinks: [true] } },
                 },
+                {
+                    displayName: 'Páginas Obligatorias a Escanear',
+                    name: 'requiredUrls',
+                    type: 'string',
+                    typeOptions: { alwaysOpenEditWindow: true },
+                    default: '',
+                    description: 'URLs completas del mismo dominio que se analizarán aunque no aparezcan en enlaces internos o sitemap. Una por línea.',
+                    displayOptions: { show: { scanInternalLinks: [true] } },
+                },
+                {
+                    displayName: 'Excluir URLs Que Contengan',
+                    name: 'excludedPatterns',
+                    type: 'string',
+                    typeOptions: { alwaysOpenEditWindow: true },
+                    default: '',
+                    description: 'Fragmentos de URL que no se analizarán ni aparecerán como errores. Uno por línea.',
+                    displayOptions: { show: { scanInternalLinks: [true] } },
+                },
                 {
                     displayName: 'Ignorar Fallos (Uno por línea)',
                     name: 'ignoredIssues',
@@ -578,6 +696,11 @@ class SeoScanner {
             apiToken,
         });
         maxInternalUrls = apiScanLimit.effectiveInternalPageLimit;
+        const incomingPlanInternalLimit = normalizePlanInternalLimit(incoming.planInternalPageLimit);
+        const effectivePlanInternalLimit = apiScanLimit.apiInternalPageLimit !== undefined
+            ? apiScanLimit.apiInternalPageLimit
+            : incomingPlanInternalLimit;
+        const effectivePlanName = incoming.planName || apiScanLimit.apiPlan || '';
         const timeoutSeconds = Math.max(5, Math.min(60, this.getNodeParameter('timeoutSeconds', 0) ?? 15));
         const timeoutMs = timeoutSeconds * 1000;
         const followRedirects = this.getNodeParameter('followRedirects', 0) !== false;
@@ -604,7 +727,9 @@ class SeoScanner {
         const generateHtmlReport = configuredHtmlReport || hasIncomingCallback;
         const detailOpts = this.getNodeParameter('detailOptions', 0) || {};
         const ignoredIssues = (this.getNodeParameter('ignoredIssues', 0, '') || '').split('\n').map(s => s.trim()).filter(Boolean);
-        const ignoredPages = (this.getNodeParameter('ignoredPages', 0, '') || '').split('\n').map(s => s.trim()).filter(Boolean);
+        const configuredRequiredUrls = (this.getNodeParameter('requiredUrls', 0, '') || '').split('\n').map(s => s.trim()).filter(Boolean);
+        const configuredExcludedPatterns = (this.getNodeParameter('excludedPatterns', 0, '') || '').split('\n').map(s => s.trim()).filter(Boolean);
+        const configuredIgnoredPages = (this.getNodeParameter('ignoredPages', 0, '') || '').split('\n').map(s => s.trim()).filter(Boolean);
         const analyzeOpts = {
             includeImageDetails: detailOpts.includeImageDetails !== false,
             includeLinkDetails: detailOpts.includeLinkDetails !== false,
@@ -630,6 +755,91 @@ class SeoScanner {
             await notifyIncomingCallbackError(incoming, apiToken, localize(errorMessage));
             return [[buildErrorOutput({ message: localize(errorMessage), url, incoming, apiToken })]];
         }
+        let requiredUrls = [];
+        let excludedPatterns = [];
+        let ignoredUrls = [];
+        if (scanInternalLinks) {
+            const normalizeUrlList = (values, label) => {
+                const urls = [];
+                const seen = new Set();
+                for (const value of values) {
+                    const normalized = normalizeCrawlAbsoluteUrl(value);
+                    if (!normalized)
+                        return { ok: false, error: `${label} debe incluir URLs completas que empiecen por http:// o https://.` };
+                    if (!sameCrawlDomain(normalized, baseUrl))
+                        return { ok: false, error: `${label} solo puede incluir URLs del mismo dominio que se está escaneando.` };
+                    const key = normalized.toLowerCase();
+                    if (seen.has(key))
+                        return { ok: false, error: `${label} no puede incluir URLs duplicadas.` };
+                    seen.add(key);
+                    urls.push(normalized);
+                }
+                return { ok: true, urls };
+            };
+            const requiredResult = normalizeUrlList(uniqueStrings([...configuredRequiredUrls, ...(incoming.requiredUrls || [])]), 'Páginas obligatorias a escanear');
+            if (!requiredResult.ok) {
+                await notifyIncomingCallbackError(incoming, apiToken, localize(requiredResult.error));
+                return [[buildErrorOutput({ message: localize(requiredResult.error), url: baseUrl, incoming, apiToken })]];
+            }
+            const ignoredResult = normalizeUrlList(uniqueStrings(incoming.ignoredUrls || []), 'URLs ignoradas');
+            if (!ignoredResult.ok) {
+                await notifyIncomingCallbackError(incoming, apiToken, localize(ignoredResult.error));
+                return [[buildErrorOutput({ message: localize(ignoredResult.error), url: baseUrl, incoming, apiToken })]];
+            }
+            requiredUrls = requiredResult.urls;
+            ignoredUrls = ignoredResult.urls;
+            if (requiredUrls.some((requiredUrl) => (0, urlUtils_1.normalizeUrlForDedupe)(requiredUrl).toLowerCase() === (0, urlUtils_1.normalizeUrlForDedupe)(baseUrl).toLowerCase())) {
+                const errorMessage = 'La URL principal ya se escanea aparte. No la añadas como página obligatoria.';
+                await notifyIncomingCallbackError(incoming, apiToken, localize(errorMessage));
+                return [[buildErrorOutput({ message: localize(errorMessage), url: baseUrl, incoming, apiToken })]];
+            }
+            const rawPatterns = uniqueStrings([
+                ...configuredIgnoredPages,
+                ...configuredExcludedPatterns,
+                ...(incoming.excludedPatterns || []),
+            ]);
+            for (const pattern of rawPatterns) {
+                const trimmed = pattern.trim();
+                if (!trimmed) {
+                    const errorMessage = 'Las reglas de exclusión no pueden estar vacías.';
+                    await notifyIncomingCallbackError(incoming, apiToken, localize(errorMessage));
+                    return [[buildErrorOutput({ message: localize(errorMessage), url: baseUrl, incoming, apiToken })]];
+                }
+                if (trimmed === '/') {
+                    const errorMessage = 'No puedes excluir solo "/", porque bloquearía todo el sitio.';
+                    await notifyIncomingCallbackError(incoming, apiToken, localize(errorMessage));
+                    return [[buildErrorOutput({ message: localize(errorMessage), url: baseUrl, incoming, apiToken })]];
+                }
+                if (urlContainsPattern(baseUrl, trimmed)) {
+                    const errorMessage = 'Una regla de exclusión no puede bloquear directamente la URL principal.';
+                    await notifyIncomingCallbackError(incoming, apiToken, localize(errorMessage));
+                    return [[buildErrorOutput({ message: localize(errorMessage), url: baseUrl, incoming, apiToken })]];
+                }
+                excludedPatterns.push(trimmed);
+            }
+            if (typeof effectivePlanInternalLimit === 'number' && maxInternalUrls > effectivePlanInternalLimit) {
+                const errorMessage = planInternalLimitError(effectivePlanInternalLimit, effectivePlanName);
+                await notifyIncomingCallbackError(incoming, apiToken, localize(errorMessage));
+                return [[buildErrorOutput({ message: localize(errorMessage), url: baseUrl, incoming, apiToken })]];
+            }
+            if (typeof effectivePlanInternalLimit === 'number' && maxInternalUrls + requiredUrls.length > effectivePlanInternalLimit) {
+                const availableRequiredSlots = effectivePlanInternalLimit - maxInternalUrls;
+                const errorMessage = requiredSlotsLimitError(availableRequiredSlots);
+                await notifyIncomingCallbackError(incoming, apiToken, localize(errorMessage));
+                return [[buildErrorOutput({ message: localize(errorMessage), url: baseUrl, incoming, apiToken })]];
+            }
+            const ignoredUrlSet = new Set(ignoredUrls.map((ignoredUrl) => ignoredUrl.toLowerCase()));
+            if (requiredUrls.some((requiredUrl) => ignoredUrlSet.has(requiredUrl.toLowerCase()))) {
+                const errorMessage = 'Una página obligatoria también está marcada como ignorada.';
+                await notifyIncomingCallbackError(incoming, apiToken, localize(errorMessage));
+                return [[buildErrorOutput({ message: localize(errorMessage), url: baseUrl, incoming, apiToken })]];
+            }
+            if (requiredUrls.some((requiredUrl) => excludedPatterns.some((pattern) => urlContainsPattern(requiredUrl, pattern)))) {
+                const errorMessage = 'Una página obligatoria coincide con una regla de exclusión.';
+                await notifyIncomingCallbackError(incoming, apiToken, localize(errorMessage));
+                return [[buildErrorOutput({ message: localize(errorMessage), url: baseUrl, incoming, apiToken })]];
+            }
+        }
         if (!apiToken) {
             try {
                 validationInfo = await validateApiKeyWithApp({
@@ -881,42 +1091,96 @@ class SeoScanner {
             let internalResults = [];
             const internalHtmlByFinalUrl = new Map();
             let crawlLimitReached = false;
+            const exactIgnoredUrls = new Set(ignoredUrls.map((ignoredUrl) => (0, urlUtils_1.normalizeUrlForDedupe)(ignoredUrl).toLowerCase()));
+            const ignoredByRuleUrls = new Map();
+            const trackIgnoredByRule = (candidate) => {
+                const norm = (0, urlUtils_1.normalizeUrlForDedupe)(candidate).toLowerCase();
+                if (!ignoredByRuleUrls.has(norm))
+                    ignoredByRuleUrls.set(norm, candidate);
+            };
+            const isSkippedByCrawlRules = (candidate) => {
+                const norm = (0, urlUtils_1.normalizeUrlForDedupe)(candidate).toLowerCase();
+                if (exactIgnoredUrls.has(norm))
+                    return true;
+                return excludedPatterns.length > 0 && isIgnoredPageUrl(candidate, excludedPatterns);
+            };
             if (scanInternalLinks) {
                 const crawlQueue = [];
                 const queuedUrls = new Set();
+                const requiredUrlSet = new Set(requiredUrls.map((requiredUrl) => (0, urlUtils_1.normalizeUrlForDedupe)(requiredUrl).toLowerCase()));
                 const scannedUrls = new Set([(0, urlUtils_1.normalizeUrlForDedupe)(mainResult.finalUrl), (0, urlUtils_1.normalizeUrlForDedupe)(baseUrl)]);
-                const addToCrawlQueue = (candidates) => {
+                let discoveredCrawlAttempts = 0;
+                let queuedDiscoveredUrls = 0;
+                const addToCrawlQueue = (candidates, source) => {
                     for (const candidate of candidates) {
-                        if (internalResults.length + crawlQueue.length >= maxInternalUrls) {
+                        if (source === 'discovered' && discoveredCrawlAttempts + queuedDiscoveredUrls >= maxInternalUrls) {
                             crawlLimitReached = true;
                             break;
                         }
                         if (!candidate || !isLikelyHtmlPageUrl(candidate))
                             continue;
-                        if (!(0, urlUtils_1.sameOrigin)(candidate, mainResult.finalUrl))
+                        if (!sameCrawlDomain(candidate, mainResult.finalUrl))
                             continue;
-                        if (ignoredPages.length > 0 && isIgnoredPageUrl(candidate, ignoredPages))
+                        if (isSkippedByCrawlRules(candidate)) {
+                            trackIgnoredByRule(candidate);
                             continue;
+                        }
                         const norm = (0, urlUtils_1.normalizeUrlForDedupe)(candidate);
                         if (scannedUrls.has(norm) || queuedUrls.has(norm))
                             continue;
                         queuedUrls.add(norm);
-                        crawlQueue.push(candidate);
+                        if (source === 'discovered')
+                            queuedDiscoveredUrls++;
+                        crawlQueue.push({ url: candidate, source });
                     }
                 };
-                addToCrawlQueue(mainResult.linksInternalUrls);
-                addToCrawlQueue(sitemapPageUrls);
-                while (crawlQueue.length > 0 && internalResults.length < maxInternalUrls) {
-                    const link = crawlQueue.shift();
+                addToCrawlQueue(requiredUrls, 'required');
+                addToCrawlQueue(mainResult.linksInternalUrls, 'discovered');
+                addToCrawlQueue(sitemapPageUrls, 'discovered');
+                while (crawlQueue.length > 0) {
+                    const queueItem = crawlQueue.shift();
+                    const link = queueItem.url;
+                    const isRequiredCrawlUrl = queueItem.source === 'required' || requiredUrlSet.has((0, urlUtils_1.normalizeUrlForDedupe)(link).toLowerCase());
+                    if (queueItem.source === 'discovered') {
+                        queuedDiscoveredUrls = Math.max(0, queuedDiscoveredUrls - 1);
+                        if (discoveredCrawlAttempts >= maxInternalUrls) {
+                            crawlLimitReached = true;
+                            break;
+                        }
+                    }
                     const requestedNorm = (0, urlUtils_1.normalizeUrlForDedupe)(link);
                     queuedUrls.delete(requestedNorm);
                     if (scannedUrls.has(requestedNorm))
                         continue;
+                    if (isSkippedByCrawlRules(link)) {
+                        trackIgnoredByRule(link);
+                        continue;
+                    }
                     scannedUrls.add(requestedNorm);
                     try {
                         const { html: innerHtml, finalUrl: innerFinal, statusCode: innerStatus, responseTimeMs: innerTime, timeToFirstByteMs: innerTtfb } = await (0, networkUtils_1.fetchPage)(link, timeoutMs, fetchOpts);
-                        if (!(0, urlUtils_1.sameOrigin)(innerFinal, mainResult.finalUrl)) {
-                            internalResults.push((0, analyzeUtils_1.createEmptySeoResult)(link, 'La URL redirige fuera del dominio escaneado'));
+                        if (!sameCrawlDomain(innerFinal, mainResult.finalUrl)) {
+                            const result = (0, analyzeUtils_1.createEmptySeoResult)(link, isRequiredCrawlUrl
+                                ? 'Página obligatoria configurada por el usuario: la URL redirige fuera del dominio escaneado'
+                                : 'La URL redirige fuera del dominio escaneado');
+                            if (queueItem.source === 'discovered')
+                                discoveredCrawlAttempts++;
+                            result.requiredUrl = isRequiredCrawlUrl;
+                            internalResults.push(result);
+                            continue;
+                        }
+                        if (innerStatus >= 400) {
+                            const result = (0, analyzeUtils_1.createEmptySeoResult)(link, isRequiredCrawlUrl
+                                ? `Página obligatoria configurada por el usuario devolvió código ${innerStatus}`
+                                : `La página devolvió código ${innerStatus}`);
+                            result.finalUrl = innerFinal;
+                            result.statusCode = innerStatus;
+                            result.responseTimeMs = innerTime;
+                            result.timeToFirstByteMs = innerTtfb;
+                            if (queueItem.source === 'discovered')
+                                discoveredCrawlAttempts++;
+                            result.requiredUrl = isRequiredCrawlUrl;
+                            internalResults.push(result);
                             continue;
                         }
                         scannedUrls.add((0, urlUtils_1.normalizeUrlForDedupe)(innerFinal));
@@ -926,14 +1190,23 @@ class SeoScanner {
                         result.statusCode = innerStatus;
                         result.responseTimeMs = innerTime;
                         internalHtmlByFinalUrl.set((0, urlUtils_1.normalizeUrlForDedupe)(innerFinal), innerHtml);
+                        result.requiredUrl = isRequiredCrawlUrl;
                         internalResults.push(result);
-                        addToCrawlQueue(result.linksInternalUrls || []);
+                        if (queueItem.source === 'discovered')
+                            discoveredCrawlAttempts++;
+                        addToCrawlQueue(result.linksInternalUrls || [], 'discovered');
                     }
                     catch {
-                        internalResults.push((0, analyzeUtils_1.createEmptySeoResult)(link, 'Error al cargar la página (timeout o red)'));
+                        const result = (0, analyzeUtils_1.createEmptySeoResult)(link, isRequiredCrawlUrl
+                            ? 'Página obligatoria configurada por el usuario: error al cargar la página (timeout o red)'
+                            : 'Error al cargar la página (timeout o red)');
+                        if (queueItem.source === 'discovered')
+                            discoveredCrawlAttempts++;
+                        result.requiredUrl = isRequiredCrawlUrl;
+                        internalResults.push(result);
                     }
                 }
-                if (crawlQueue.length > 0 && internalResults.length >= maxInternalUrls) {
+                if (crawlQueue.some((item) => item.source === 'discovered') && discoveredCrawlAttempts >= maxInternalUrls) {
                     crawlLimitReached = true;
                 }
                 output.internalPages = internalResults;
@@ -941,9 +1214,16 @@ class SeoScanner {
                 output.message = `Escaneadas ${output.scannedUrls} páginas (1 principal + ${internalResults.length} URLs internas descubiertas).`;
                 output.siteCrawlDiscovery = {
                     limit: maxInternalUrls,
+                    requiredUrls: requiredUrls.length,
+                    totalInternalLimit: maxInternalUrls + requiredUrls.length,
+                    planInternalLimit: effectivePlanInternalLimit === undefined ? null : effectivePlanInternalLimit,
+                    discoveredCrawlLimit: maxInternalUrls,
+                    discoveredCrawlScanned: discoveredCrawlAttempts,
+                    excludedPatterns: excludedPatterns.length,
                     sitemapSeedUrls: sitemapPageUrls.length,
                     totalDiscoveredInternalUrls: scannedUrls.size + queuedUrls.size,
                     pendingUrlsNotScanned: crawlQueue.length,
+                    ignoredUrlsCount: ignoredByRuleUrls.size,
                 };
                 if (analyzeOpts.checkBrokenLinks) {
                     const maxSiteCheck = Math.min(100, Math.max(analyzeOpts.maxBrokenLinksToCheck ?? 15, 30));
@@ -952,6 +1232,8 @@ class SeoScanner {
                     const toCheckSite = [];
                     const addInternal = (url, anchor) => {
                         const norm = (0, urlUtils_1.normalizeUrlForDedupe)(url);
+                        if (isSkippedByCrawlRules(url))
+                            return;
                         if (!seenInternal.has(norm) && isHttp(url)) {
                             seenInternal.add(norm);
                             if (toCheckSite.length < maxSiteCheck)
@@ -960,6 +1242,8 @@ class SeoScanner {
                     };
                     const addExternal = (url, anchor) => {
                         const norm = url.toLowerCase();
+                        if (isSkippedByCrawlRules(url))
+                            return;
                         if (!seenExternal.has(norm) && isHttp(url)) {
                             seenExternal.add(norm);
                             if (toCheckSite.length < maxSiteCheck)
@@ -1041,14 +1325,24 @@ class SeoScanner {
             }
             if (sitemapPageUrls.length > 0) {
                 const allDiscoveredLinks = new Set();
-                mainResult.linksInternalUrls.forEach(u => allDiscoveredLinks.add((0, urlUtils_1.normalizeUrlForDedupe)(u)));
+                mainResult.linksInternalUrls.forEach(u => {
+                    if (!isSkippedByCrawlRules(u))
+                        allDiscoveredLinks.add((0, urlUtils_1.normalizeUrlForDedupe)(u));
+                });
                 if (internalResults.length > 0) {
                     internalResults.forEach(r => {
-                        (r.linksInternalUrls || []).forEach(u => allDiscoveredLinks.add((0, urlUtils_1.normalizeUrlForDedupe)(u)));
+                        (r.linksInternalUrls || []).forEach(u => {
+                            if (!isSkippedByCrawlRules(u))
+                                allDiscoveredLinks.add((0, urlUtils_1.normalizeUrlForDedupe)(u));
+                        });
                     });
                 }
                 const orphanPages = [];
                 for (const sitemapUrl of sitemapPageUrls) {
+                    if (isSkippedByCrawlRules(sitemapUrl)) {
+                        trackIgnoredByRule(sitemapUrl);
+                        continue;
+                    }
                     const norm = (0, urlUtils_1.normalizeUrlForDedupe)(sitemapUrl);
                     if (norm !== (0, urlUtils_1.normalizeUrlForDedupe)(mainResult.finalUrl) &&
                         !internalResults.some(r => (0, urlUtils_1.normalizeUrlForDedupe)(r.finalUrl) === norm) &&
@@ -1076,6 +1370,14 @@ class SeoScanner {
                     output.summary.orphanPagesCount = 0;
                 }
             }
+            if (ignoredByRuleUrls.size > 0) {
+                output.ignoredUrls = [...ignoredByRuleUrls.values()];
+                output.ignoredUrlsCount = ignoredByRuleUrls.size;
+                output.ignoredUrlsSummary = `${ignoredByRuleUrls.size} URLs ignoradas por reglas de exclusión.`;
+                if (output.siteCrawlDiscovery && typeof output.siteCrawlDiscovery === 'object') {
+                    output.siteCrawlDiscovery.ignoredUrlsCount = ignoredByRuleUrls.size;
+                }
+            }
             if (apiScanLimit.apiLimitSource) {
                 const apiCreditsRemaining = (0, apiLimitUtils_1.resolveApiCreditsRemaining)({ apiToken, incoming, validationInfo });
                 output.apiUsage = (0, apiLimitUtils_1.buildApiUsagePayload)(apiScanLimit, apiCreditsRemaining);