@se-studio/site-check 1.1.3 → 1.3.1

package/dist/production-audit/index.js

@@ -0,0 +1,794 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+const STOPWORDS = new Set([
+    'a',
+    'an',
+    'and',
+    'are',
+    'as',
+    'at',
+    'be',
+    'by',
+    'for',
+    'from',
+    'in',
+    'is',
+    'it',
+    'of',
+    'on',
+    'or',
+    'the',
+    'to',
+    'with',
+    'our',
+    'your',
+    'we',
+    'us',
+]);
+function escapeCsv(value) {
+    if (/[",\n]/.test(value))
+        return `"${value.replace(/"/g, '""')}"`;
+    return value;
+}
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/$/, '');
+}
+function normalizePageUrl(url, trailingSlash) {
+    const parsed = new URL(url);
+    let pathname = parsed.pathname;
+    if (pathname !== '/' && trailingSlash && !pathname.endsWith('/')) {
+        pathname = `${pathname}/`;
+    }
+    if (pathname !== '/' && !trailingSlash && pathname.endsWith('/')) {
+        pathname = pathname.slice(0, -1);
+    }
+    parsed.pathname = pathname;
+    return parsed.toString();
+}
+export function htmlUrlToMarkdownUrl(pageUrl) {
+    const parsed = new URL(pageUrl);
+    if (parsed.pathname === '/' || parsed.pathname === '') {
+        parsed.pathname = '/index.md';
+        return parsed.toString();
+    }
+    const path = parsed.pathname.endsWith('/')
+        ? `${parsed.pathname.slice(0, -1)}.md`
+        : `${parsed.pathname}.md`;
+    parsed.pathname = path;
+    return parsed.toString();
+}
+function parseSitemapLocs(xml) {
+    const locs = [];
+    const re = /<loc>\s*([^<]+?)\s*<\/loc>/gi;
+    let match = re.exec(xml);
+    while (match) {
+        const loc = match[1];
+        if (loc)
+            locs.push(loc.trim());
+        match = re.exec(xml);
+    }
+    return [...new Set(locs)];
+}
+export function parseMarkdownIndexUrls(text, baseUrl) {
+    const base = normalizeBaseUrl(baseUrl);
+    const urls = [];
+    for (const line of text.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('http'))
+            continue;
+        let htmlUrl = trimmed;
+        if (htmlUrl.endsWith('/index.md')) {
+            htmlUrl = `${base}/`;
+        }
+        else if (htmlUrl.endsWith('.md')) {
+            htmlUrl = `${htmlUrl.slice(0, -3)}/`;
+        }
+        urls.push(normalizePageUrl(htmlUrl, true));
+    }
+    return urls;
+}
+function stripHtml(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function extractAttr(tag, attr) {
+    const re = new RegExp(`${attr}\\s*=\\s*["']([^"']*)["']`, 'i');
+    const m = tag.match(re);
+    return m?.[1];
+}
+function extractMetaContent(html, name) {
+    const re = new RegExp(`<meta[^>]+(?:name=["']${name}["'][^>]+content=["']([^"']*)["']|content=["']([^"']*)["'][^>]+name=["']${name}["'])`, 'i');
+    const m = html.match(re);
+    return (m?.[1] ?? m?.[2] ?? '').trim();
+}
+function extractTitle(html) {
+    const m = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+    return m?.[1] ? stripHtml(m[1]) : '';
+}
+function extractCanonical(html) {
+    const tags = html.match(/<link[^>]+>/gi) ?? [];
+    for (const tag of tags) {
+        if (!/rel=["']canonical["']/i.test(tag))
+            continue;
+        return extractAttr(tag, 'href') ?? '';
+    }
+    return '';
+}
+function extractH1(html) {
+    const m = html.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i);
+    return m?.[1] ? stripHtml(m[1]) : '';
+}
+function extractMainTextLen(html) {
+    const mainMatch = html.match(/<main[^>]*>([\s\S]*?)<\/main>/i);
+    if (mainMatch?.[1])
+        return stripHtml(mainMatch[1]).length;
+    let body = html.replace(/<nav[\s\S]*?<\/nav>/gi, ' ');
+    body = body.replace(/<footer[\s\S]*?<\/footer>/gi, ' ');
+    const bodyMatch = body.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
+    return bodyMatch?.[1] ? stripHtml(bodyMatch[1]).length : stripHtml(html).length;
+}
+function extractJsonLdBlocks(html) {
+    const blocks = [];
+    const re = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+    let match = re.exec(html);
+    while (match) {
+        const block = match[1];
+        if (block)
+            blocks.push(block.trim());
+        match = re.exec(html);
+    }
+    return blocks;
+}
+function significantTokens(text) {
+    const tokens = new Set();
+    for (const raw of text.toLowerCase().split(/[^a-z0-9]+/)) {
+        if (raw.length < 2 || STOPWORDS.has(raw))
+            continue;
+        tokens.add(raw);
+    }
+    return tokens;
+}
+function tokenOverlap(a, b) {
+    let count = 0;
+    for (const t of a) {
+        if (b.has(t))
+            count++;
+    }
+    return count;
+}
+function stripBrandSuffix(title, siteTitle) {
+    const suffix = `| ${siteTitle}`;
+    if (title.endsWith(suffix))
+        return title.slice(0, -suffix.length).trim();
+    return title;
+}
+function slugTokens(pathname) {
+    const segments = pathname
+        .replace(/^\/|\/$/g, '')
+        .split('/')
+        .filter(Boolean);
+    const last = segments.at(-1) ?? '';
+    return significantTokens(last.replace(/-/g, ' '));
+}
+function collectSchemaTypes(value, types) {
+    if (!value || typeof value !== 'object')
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectSchemaTypes(item, types);
+        return;
+    }
+    const obj = value;
+    if (typeof obj['@type'] === 'string')
+        types.add(obj['@type']);
+    if (Array.isArray(obj['@type'])) {
+        for (const t of obj['@type']) {
+            if (typeof t === 'string')
+                types.add(t);
+        }
+    }
+    if (obj['@graph'])
+        collectSchemaTypes(obj['@graph'], types);
+    for (const v of Object.values(obj)) {
+        if (v && typeof v === 'object')
+            collectSchemaTypes(v, types);
+    }
+}
+function parseLinkCanonical(headers) {
+    const link = headers.get('link');
+    if (!link)
+        return undefined;
+    const m = link.match(/<([^>]+)>;\s*rel="canonical"/i);
+    return m?.[1];
+}
+function urlsEquivalent(a, b, trailingSlash) {
+    try {
+        return normalizePageUrl(a, trailingSlash) === normalizePageUrl(b, trailingSlash);
+    }
+    catch {
+        return a === b;
+    }
+}
+/** CMS Mustache placeholders ({{var}} / {{{var}}}), not JSON `}}` closers or `{search_term_string}`. */
+export function hasUnfilledMustache(text) {
+    return /\{\{\{[^}]+\}\}\}/.test(text) || /\{\{[^}]+\}\}/.test(text);
+}
+function shouldSkipMarkdown(pathname, prefixes) {
+    return prefixes.some((p) => pathname.startsWith(p.startsWith('/') ? p : `/${p}`));
+}
+function classifyRow(input) {
+    const titleFlags = [];
+    const descFlags = [];
+    const schemaFlags = [];
+    const contentFlags = [];
+    const jsonldErrors = [];
+    const schemaTypes = new Set();
+    const isHome = input.pathname === '/' || input.pathname === '';
+    if (input.httpStatus !== 200)
+        contentFlags.push('http_error');
+    if (!input.title) {
+        titleFlags.push('missing_title');
+    }
+    else if (isHome) {
+        if (input.title !== input.siteTitle)
+            titleFlags.push('homepage_title_unexpected');
+    }
+    else {
+        const titleCore = stripBrandSuffix(input.title, input.siteTitle);
+        if (titleCore === input.siteTitle)
+            titleFlags.push('generic_title');
+        const slugTok = slugTokens(input.pathname);
+        const titleTok = significantTokens(titleCore);
+        const h1Tok = significantTokens(input.h1);
+        if (slugTok.size > 0 &&
+            tokenOverlap(slugTok, titleTok) === 0 &&
+            tokenOverlap(slugTok, h1Tok) === 0) {
+            titleFlags.push('title_slug_mismatch');
+        }
+        const h1WordCount = input.h1.split(/\s+/).filter(Boolean).length;
+        if (h1WordCount >= 4 && tokenOverlap(significantTokens(titleCore), h1Tok) < 1) {
+            titleFlags.push('title_h1_mismatch');
+        }
+        for (const prefix of input.articlePathPrefixes) {
+            if (!input.pathname.startsWith(`/${prefix}/`))
+                continue;
+            const segments = input.pathname.replace(`/${prefix}/`, '').split('/').filter(Boolean);
+            if (segments.length < 2)
+                continue;
+            const articleSlug = segments.at(-1) ?? '';
+            const slugWords = significantTokens(articleSlug.replace(/-/g, ' '));
+            if (slugWords.size > 0 && tokenOverlap(slugWords, titleTok) === 0) {
+                titleFlags.push('article_title_slug_mismatch');
+            }
+        }
+    }
+    if (!input.description) {
+        descFlags.push('missing_description');
+    }
+    else {
+        if (hasUnfilledMustache(input.description))
+            descFlags.push('mustache_leak');
+        if (input.description.length < 50)
+            descFlags.push('short_description');
+        else if (input.description.length > 160)
+            descFlags.push('long_description');
+        else if (input.description.length < 120)
+            descFlags.push('suboptimal_description');
+    }
+    const thinContentExempt = /^\/(tags|categories|resources\/news|resources\/publications)\//.test(input.pathname) &&
+        input.pathname.split('/').filter(Boolean).length <= 3;
+    if (input.mainTextLen < input.thinContentThreshold &&
+        input.httpStatus === 200 &&
+        !thinContentExempt) {
+        contentFlags.push('thin_content');
+    }
+    if (input.jsonLdBlocks.length === 0 && !input.noindex && input.httpStatus === 200) {
+        schemaFlags.push('missing_jsonld');
+    }
+    for (const block of input.jsonLdBlocks) {
+        if (hasUnfilledMustache(block))
+            schemaFlags.push('unfilled_mustache');
+        try {
+            const parsed = JSON.parse(block);
+            const serialized = JSON.stringify(parsed);
+            if (!/schema\.org/i.test(serialized))
+                schemaFlags.push('missing_schema_context');
+            collectSchemaTypes(parsed, schemaTypes);
+            const hasType = schemaTypes.size > 0;
+            if (!hasType)
+                schemaFlags.push('missing_schema_type');
+        }
+        catch {
+            jsonldErrors.push('invalid_json');
+        }
+    }
+    if (isHome && input.httpStatus === 200 && !input.noindex) {
+        if (!schemaTypes.has('Organization'))
+            schemaFlags.push('expected_organization');
+        if (!schemaTypes.has('WebSite'))
+            schemaFlags.push('expected_website');
+    }
+    if (input.pathname.startsWith('/people/') && input.httpStatus === 200) {
+        if (!schemaTypes.has('Person') && !schemaTypes.has('ProfilePage')) {
+            schemaFlags.push('expected_person_schema');
+        }
+    }
+    for (const prefix of input.articlePathPrefixes) {
+        if (input.pathname.startsWith(`/${prefix}/`) && input.pathname.split('/').length > 3) {
+            if (!schemaTypes.has('BlogPosting') &&
+                !schemaTypes.has('ScholarlyArticle') &&
+                !schemaTypes.has('NewsArticle')) {
+                schemaFlags.push('expected_article_schema');
+            }
+        }
+        if (input.pathname === `/${prefix}/` || input.pathname === `/${prefix}`) {
+            if (!schemaTypes.has('CollectionPage'))
+                schemaFlags.push('expected_collection_page');
+        }
+    }
+    if (input.pathname.startsWith('/categories/') && input.httpStatus === 200) {
+        if (!schemaTypes.has('CollectionPage'))
+            schemaFlags.push('expected_collection_page');
+    }
+    if (input.expectMarkdown) {
+        if (input.mdStatus !== 200) {
+            contentFlags.push('markdown_missing');
+        }
+        else if (input.mdLen < 50) {
+            contentFlags.push('markdown_empty');
+        }
+        if (input.mdCanonical &&
+            !urlsEquivalent(input.mdCanonical, input.pageUrl, input.trailingSlash)) {
+            contentFlags.push('markdown_canonical_mismatch');
+        }
+    }
+    const errorFlags = new Set([
+        'http_error',
+        'missing_title',
+        'missing_description',
+        'mustache_leak',
+        'missing_jsonld',
+        'invalid_json',
+        'unfilled_mustache',
+        'markdown_missing',
+        'markdown_empty',
+        'markdown_canonical_mismatch',
+    ]);
+    const all = [...titleFlags, ...descFlags, ...schemaFlags, ...contentFlags, ...jsonldErrors];
+    let severity = 'ok';
+    if (all.some((f) => errorFlags.has(f)))
+        severity = 'error';
+    else if (all.length > 0)
+        severity = 'warn';
+    return {
+        titleFlags,
+        descFlags,
+        schemaFlags,
+        contentFlags,
+        jsonldErrors,
+        schemaTypes,
+        severity,
+    };
+}
+async function fetchWithTimeout(url, init, timeoutMs = 30_000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal, redirect: 'follow' });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function mapPool(items, concurrency, fn) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function worker() {
+        while (true) {
+            const i = nextIndex++;
+            if (i >= items.length)
+                return;
+            const item = items[i];
+            if (item === undefined)
+                return;
+            results[i] = await fn(item, i);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+    return results;
+}
+export async function runProductionSeoAudit(config) {
+    const base = normalizeBaseUrl(config.baseUrl);
+    const trailingSlash = config.trailingSlash ?? true;
+    const sitemapUrl = `${base}${config.sitemapPath ?? '/sitemap.xml'}`;
+    const markdownIndexUrl = `${base}${config.markdownIndexPath ?? '/markdown-index.txt'}`;
+    const concurrency = config.concurrency ?? 8;
+    const thinContentThreshold = config.thinContentThreshold ?? 200;
+    const minMarkdownLength = config.minMarkdownLength ?? 50;
+    const requestDelayMs = config.requestDelayMs ?? 0;
+    const articlePathPrefixes = config.articlePathPrefixes ?? [];
+    const skipMarkdownPathPrefixes = config.skipMarkdownPathPrefixes ?? ['/download/'];
+    const sitemapRes = await fetchWithTimeout(sitemapUrl);
+    if (!sitemapRes.ok)
+        throw new Error(`Failed to fetch sitemap: ${sitemapRes.status} ${sitemapUrl}`);
+    const sitemapXml = await sitemapRes.text();
+    const sitemapUrls = parseSitemapLocs(sitemapXml).map((u) => normalizePageUrl(u, trailingSlash));
+    let markdownIndexUrls = [];
+    try {
+        const indexRes = await fetchWithTimeout(markdownIndexUrl);
+        if (indexRes.ok) {
+            const indexText = await indexRes.text();
+            markdownIndexUrls = parseMarkdownIndexUrls(indexText, base);
+        }
+    }
+    catch {
+        // optional cross-check
+    }
+    const markdownSet = new Set(markdownIndexUrls.map((u) => normalizePageUrl(u, trailingSlash)));
+    const missingFromMarkdownIndex = sitemapUrls.filter((u) => !markdownSet.has(u));
+    const rows = await mapPool(sitemapUrls, concurrency, async (pageUrl) => {
+        if (requestDelayMs > 0)
+            await new Promise((r) => setTimeout(r, requestDelayMs));
+        const htmlRes = await fetchWithTimeout(pageUrl, {
+            headers: { Accept: 'text/html', 'User-Agent': 'PedestalProductionSeoAudit/1.0' },
+        });
+        const html = htmlRes.ok ? await htmlRes.text() : '';
+        const pathname = new URL(htmlRes.url || pageUrl).pathname;
+        const title = extractTitle(html);
+        const description = extractMetaContent(html, 'description');
+        const h1 = extractH1(html);
+        const mainTextLen = extractMainTextLen(html);
+        const canonical = extractCanonical(html) || pageUrl;
+        const robots = extractMetaContent(html, 'robots');
+        const noindex = /noindex/i.test(robots);
+        const jsonLdBlocks = extractJsonLdBlocks(html);
+        const normalizedPageUrl = normalizePageUrl(htmlRes.url || pageUrl, trailingSlash);
+        const inMarkdownIndex = markdownSet.has(normalizedPageUrl);
+        const expectMarkdown = inMarkdownIndex && !shouldSkipMarkdown(pathname, skipMarkdownPathPrefixes);
+        const mdUrl = htmlUrlToMarkdownUrl(pageUrl);
+        let mdStatus = 0;
+        let mdLen = 0;
+        let mdCanonical;
+        if (expectMarkdown) {
+            try {
+                const mdRes = await fetchWithTimeout(mdUrl, {
+                    headers: { Accept: 'text/markdown', 'User-Agent': 'PedestalProductionSeoAudit/1.0' },
+                });
+                mdStatus = mdRes.status;
+                if (mdRes.ok) {
+                    const mdText = await mdRes.text();
+                    mdLen = mdText.trim().length;
+                    mdCanonical = parseLinkCanonical(mdRes.headers);
+                }
+            }
+            catch {
+                mdStatus = 0;
+            }
+        }
+        const classified = classifyRow({
+            url: pageUrl,
+            pathname,
+            siteTitle: config.siteTitle,
+            title,
+            description,
+            h1,
+            mainTextLen,
+            httpStatus: htmlRes.status,
+            noindex,
+            jsonLdBlocks,
+            articlePathPrefixes,
+            thinContentThreshold,
+            mdStatus,
+            mdLen: mdLen,
+            mdCanonical,
+            pageUrl: normalizedPageUrl,
+            trailingSlash,
+            inMarkdownIndex,
+            expectMarkdown,
+        });
+        const allFlags = [
+            ...classified.titleFlags,
+            ...classified.descFlags,
+            ...classified.schemaFlags,
+            ...classified.contentFlags,
+            ...classified.jsonldErrors,
+        ];
+        if (mdLen < minMarkdownLength && mdStatus === 200) {
+            allFlags.push('markdown_short');
+        }
+        return {
+            url: pageUrl,
+            finalUrl: htmlRes.url || pageUrl,
+            httpStatus: htmlRes.status,
+            title,
+            description,
+            descLen: description.length,
+            h1,
+            mainTextLen,
+            canonical,
+            noindex,
+            jsonldCount: jsonLdBlocks.length,
+            jsonldErrors: classified.jsonldErrors.join(';'),
+            schemaTypes: [...classified.schemaTypes].sort().join(', '),
+            titleFlags: classified.titleFlags.join(';'),
+            descFlags: classified.descFlags.join(';'),
+            schemaFlags: classified.schemaFlags.join(';'),
+            contentFlags: classified.contentFlags.join(';'),
+            mdStatus,
+            mdLen,
+            mdCanonicalOk: !expectMarkdown
+                ? true
+                : mdCanonical
+                    ? urlsEquivalent(mdCanonical, normalizedPageUrl, trailingSlash)
+                    : mdStatus === 200,
+            allFlags: [...new Set(allFlags)].join(';'),
+            severity: classified.severity,
+        };
+    });
+    const flagCounts = {};
+    let errorCount = 0;
+    let warnCount = 0;
+    for (const row of rows) {
+        if (row.severity === 'error')
+            errorCount++;
+        if (row.severity === 'warn')
+            warnCount++;
+        for (const flag of row.allFlags.split(';').filter(Boolean)) {
+            flagCounts[flag] = (flagCounts[flag] ?? 0) + 1;
+        }
+    }
+    if (missingFromMarkdownIndex.length > 0) {
+        flagCounts.missing_from_markdown_index = missingFromMarkdownIndex.length;
+    }
+    return {
+        rows,
+        sitemapUrlCount: sitemapUrls.length,
+        markdownIndexUrlCount: markdownIndexUrls.length,
+        missingFromMarkdownIndex,
+        flagCounts,
+        errorCount,
+        warnCount,
+    };
+}
+const CSV_HEADERS = [
+    'url',
+    'finalUrl',
+    'httpStatus',
+    'title',
+    'description',
+    'descLen',
+    'h1',
+    'mainTextLen',
+    'canonical',
+    'noindex',
+    'jsonldCount',
+    'jsonldErrors',
+    'schemaTypes',
+    'titleFlags',
+    'descFlags',
+    'schemaFlags',
+    'contentFlags',
+    'mdStatus',
+    'mdLen',
+    'mdCanonicalOk',
+    'allFlags',
+    'severity',
+];
+export function rowsToCsv(rows) {
+    const lines = [CSV_HEADERS.join(',')];
+    for (const row of rows) {
+        lines.push([
+            row.url,
+            row.finalUrl,
+            String(row.httpStatus),
+            row.title,
+            row.description,
+            String(row.descLen),
+            row.h1,
+            String(row.mainTextLen),
+            row.canonical,
+            row.noindex ? 'true' : 'false',
+            String(row.jsonldCount),
+            row.jsonldErrors,
+            row.schemaTypes,
+            row.titleFlags,
+            row.descFlags,
+            row.schemaFlags,
+            row.contentFlags,
+            String(row.mdStatus),
+            String(row.mdLen),
+            row.mdCanonicalOk ? 'true' : 'false',
+            row.allFlags,
+            row.severity,
+        ]
+            .map(escapeCsv)
+            .join(','));
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function evaluateRichResultsSpotCheck(input) {
+    const types = input.schemaTypes;
+    let result = 'pass';
+    const notes = [];
+    if (input.httpStatus !== 200) {
+        return {
+            label: input.label,
+            url: input.url,
+            result: 'fail',
+            notes: `HTTP ${input.httpStatus}`,
+        };
+    }
+    if (input.jsonldErrors.length > 0) {
+        return {
+            label: input.label,
+            url: input.url,
+            result: 'fail',
+            notes: input.jsonldErrors.join(', '),
+        };
+    }
+    if (types.size === 0) {
+        return { label: input.label, url: input.url, result: 'fail', notes: 'No JSON-LD types' };
+    }
+    const pathname = new URL(input.url).pathname;
+    if (pathname === '/' || pathname === '') {
+        if (!types.has('Organization'))
+            notes.push('missing Organization');
+        if (!types.has('WebSite'))
+            notes.push('missing WebSite');
+    }
+    else if (pathname.startsWith('/people/')) {
+        if (!types.has('Person') && !types.has('ProfilePage'))
+            notes.push('missing Person/ProfilePage');
+    }
+    else if (pathname.startsWith('/categories/')) {
+        if (!types.has('CollectionPage'))
+            notes.push('missing CollectionPage (warn)');
+    }
+    else if (pathname.match(/^\/resources\/news\/[^/]+\/[^/]+\/$/)) {
+        if (!types.has('BlogPosting') && !types.has('NewsArticle') && !types.has('ScholarlyArticle')) {
+            notes.push('missing article schema');
+        }
+    }
+    else if (pathname.startsWith('/resources/publications/') && pathname.split('/').length > 5) {
+        if (!types.has('ScholarlyArticle') && !types.has('BlogPosting')) {
+            notes.push('missing ScholarlyArticle/BlogPosting');
+        }
+    }
+    else if (pathname === '/resources/news/' || pathname === '/resources/news') {
+        if (!types.has('CollectionPage'))
+            notes.push('missing CollectionPage (warn)');
+    }
+    if (notes.length > 0) {
+        result = notes.some((n) => n.startsWith('missing CollectionPage')) ? 'warn' : 'fail';
+    }
+    return {
+        label: input.label,
+        url: input.url,
+        result,
+        notes: notes.length > 0 ? notes.join('; ') : `Types: ${[...types].sort().join(', ')}`,
+    };
+}
+export function pickRichResultsSampleUrls(rows, baseUrl) {
+    const base = normalizeBaseUrl(baseUrl);
+    const find = (pred) => rows.find(pred)?.url;
+    const newsArticle = find((r) => r.url.includes('/resources/news/') &&
+        r.url.replace(base, '').split('/').filter(Boolean).length >= 4 &&
+        r.httpStatus === 200);
+    const publication = find((r) => r.url.includes('/resources/publications/') &&
+        r.url.includes('/abstract-manuscript/') &&
+        r.httpStatus === 200);
+    const person = find((r) => {
+        const segments = r.url.replace(base, '').split('/').filter(Boolean);
+        return (segments[0] === 'people' && segments.length >= 2 && r.httpStatus === 200 && r.jsonldCount > 0);
+    });
+    const category = find((r) => {
+        const segments = r.url.replace(base, '').split('/').filter(Boolean);
+        return segments[0] === 'categories' && segments.length >= 2 && r.httpStatus === 200;
+    });
+    return [
+        { label: 'Homepage', url: `${base}/` },
+        { label: 'News hub', url: `${base}/resources/news/` },
+        ...(newsArticle ? [{ label: 'News article', url: newsArticle }] : []),
+        ...(publication ? [{ label: 'Publication', url: publication }] : []),
+        ...(person ? [{ label: 'Person', url: person }] : []),
+        ...(category ? [{ label: 'Category hub', url: category }] : []),
+    ];
+}
+export function buildRichResultsSpotChecks(rows, config) {
+    const samples = pickRichResultsSampleUrls(rows, config.baseUrl);
+    const rowByUrl = new Map(rows.map((r) => [normalizePageUrl(r.url, config.trailingSlash ?? true), r]));
+    return samples.map(({ label, url }) => {
+        const row = rowByUrl.get(normalizePageUrl(url, config.trailingSlash ?? true));
+        const types = new Set(row?.schemaTypes
+            ? row.schemaTypes
+                .split(',')
+                .map((t) => t.trim())
+                .filter(Boolean)
+            : []);
+        return evaluateRichResultsSpotCheck({
+            label,
+            url,
+            httpStatus: row?.httpStatus ?? 0,
+            schemaTypes: types,
+            jsonldErrors: row?.jsonldErrors ? row.jsonldErrors.split(';').filter(Boolean) : [],
+        });
+    });
+}
+export function buildMarkdownReport(result, config, richResults) {
+    const sortedFlags = Object.entries(result.flagCounts).sort((a, b) => b[1] - a[1]);
+    const errors = result.rows.filter((r) => r.severity === 'error');
+    const warns = result.rows.filter((r) => r.severity === 'warn');
+    const lines = [
+        '# Pedestal production SEO audit',
+        '',
+        `**Site:** ${config.baseUrl}`,
+        `**Generated:** ${new Date().toISOString()}`,
+        '',
+        '## Summary',
+        '',
+        `| Metric | Count |`,
+        `|--------|------:|`,
+        `| Sitemap URLs crawled | ${result.sitemapUrlCount} |`,
+        `| Markdown index URLs | ${result.markdownIndexUrlCount} |`,
+        `| Rows with errors | ${result.errorCount} |`,
+        `| Rows with warnings | ${result.warnCount} |`,
+        `| Missing from markdown-index.txt | ${result.missingFromMarkdownIndex.length} |`,
+        '',
+        '## Flag counts',
+        '',
+        '| Flag | Count |',
+        '|------|------:|',
+        ...sortedFlags.map(([flag, count]) => `| ${flag} | ${count} |`),
+        '',
+    ];
+    if (errors.length > 0) {
+        lines.push('## Errors (sample)', '', '| URL | Flags |', '|-----|-------|');
+        for (const row of errors.slice(0, 40)) {
+            lines.push(`| ${row.url} | ${row.allFlags} |`);
+        }
+        if (errors.length > 40)
+            lines.push('', `_…and ${errors.length - 40} more. See CSV._`);
+        lines.push('');
+    }
+    if (warns.length > 0) {
+        lines.push('## Warnings (sample)', '', '| URL | Flags |', '|-----|-------|');
+        for (const row of warns.slice(0, 30)) {
+            lines.push(`| ${row.url} | ${row.allFlags} |`);
+        }
+        if (warns.length > 30)
+            lines.push('', `_…and ${warns.length - 30} more. See CSV._`);
+        lines.push('');
+    }
+    if (result.missingFromMarkdownIndex.length > 0) {
+        lines.push('## Missing from markdown-index.txt', '');
+        for (const url of result.missingFromMarkdownIndex.slice(0, 50)) {
+            lines.push(`- ${url}`);
+        }
+        if (result.missingFromMarkdownIndex.length > 50) {
+            lines.push(`- _…and ${result.missingFromMarkdownIndex.length - 50} more_`);
+        }
+        lines.push('');
+    }
+    const spotChecks = richResults ?? [];
+    lines.push('## Rich Results spot-check', '', 'Automated JSON-LD type checks on representative URLs. Confirm in [Google Rich Results Test](https://search.google.com/test/rich-results) if needed.', '', '| Page | URL | Result | Notes |', '|------|-----|--------|-------|', ...(spotChecks.length > 0
+        ? spotChecks.map((s) => `| ${s.label} | ${s.url} | ${s.result} | ${s.notes} |`)
+        : ['| (no samples) | | | |']), '');
+    return lines.join('\n');
+}
+export async function writeProductionSeoAuditOutputs(result, config, richResults) {
+    await mkdir(config.outputDir, { recursive: true });
+    const csvPath = path.join(config.outputDir, config.outputCsvName ?? 'pedestal-production-audit.csv');
+    const mdPath = path.join(config.outputDir, config.outputMdName ?? 'pedestal-production-audit.md');
+    const spotChecks = richResults ?? buildRichResultsSpotChecks(result.rows, config);
+    await writeFile(csvPath, rowsToCsv(result.rows), 'utf8');
+    await writeFile(mdPath, buildMarkdownReport(result, config, spotChecks), 'utf8');
+    return { csvPath, mdPath };
+}
+export function getProductionAuditExitCode(result) {
+    return result.errorCount > 0 ? 1 : 0;
+}
+//# sourceMappingURL=index.js.map