@orion-studios/payload-seo-audit 1.0.0

package/dist/utilities/crawler.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crawlSiteForSEO = void 0;
+const helpers_1 = require("../utilities/helpers");
+const https_1 = __importDefault(require("https"));
+const extractSitemapURLs = (xml) => {
+    const matches = [...xml.matchAll(/<loc>(.*?)<\/loc>/gi)];
+    return matches.map((match) => match[1]?.trim()).filter(Boolean);
+};
+const extractInternalLinks = (html, baseOrigin) => {
+    const links = [...html.matchAll(/<a\s+[^>]*href=["']([^"']+)["'][^>]*>/gi)]
+        .map((match) => match[1]?.trim())
+        .filter(Boolean);
+    return links
+        .map((link) => (0, helpers_1.safeUrl)(link, baseOrigin))
+        .filter((link) => Boolean(link))
+        .map((link) => (0, helpers_1.normalizeURL)(link))
+        .filter((link) => {
+        try {
+            return new URL(link).origin === baseOrigin;
+        }
+        catch {
+            return false;
+        }
+    });
+};
+const matchesPatterns = (url, patterns) => {
+    if (!patterns?.length)
+        return true;
+    return patterns.some((entry) => {
+        const pattern = entry?.pattern?.trim();
+        if (!pattern)
+            return false;
+        return url.includes(pattern);
+    });
+};
+const isExcluded = (url, patterns) => {
+    if (!patterns?.length)
+        return false;
+    return patterns.some((entry) => {
+        const pattern = entry?.pattern?.trim();
+        if (!pattern)
+            return false;
+        return url.includes(pattern);
+    });
+};
+const httpsAgent = process.env.NODE_ENV === 'development'
+    ? new https_1.default.Agent({
+        rejectUnauthorized: false,
+    })
+    : undefined;
+const fetchWithTimeout = async (url, timeoutMs) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, {
+            signal: controller.signal,
+            headers: {
+                'user-agent': 'OrionStudiosSEOAudit/1.0',
+            },
+            cache: 'no-store',
+            ...(httpsAgent && { agent: httpsAgent }),
+        });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+};
+const crawlSiteForSEO = async (site) => {
+    const canonicalHost = site.canonicalHost?.trim();
+    const sitemapURL = site.sitemapURL?.trim();
+    if (!canonicalHost || !sitemapURL) {
+        return { pages: [], visitedCount: 0 };
+    }
+    const origin = new URL(canonicalHost).origin;
+    const maxPages = Math.max(10, Number(site.crawlSettings?.maxPages || 120));
+    const maxDepth = Math.max(0, Number(site.crawlSettings?.maxDepth || 2));
+    const timeoutMs = Math.max(1000, Number(site.crawlSettings?.requestTimeoutMs || 10000));
+    const includePatterns = site.crawlSettings?.includePatterns;
+    const excludePatterns = site.crawlSettings?.excludePatterns;
+    const queued = new Set();
+    const visited = new Set();
+    const queue = [];
+    const pages = [];
+    const enqueue = (value, depth) => {
+        const normalized = (0, helpers_1.normalizeURL)(value);
+        if (queued.has(normalized) || visited.has(normalized))
+            return;
+        if (isExcluded(normalized, excludePatterns))
+            return;
+        if (!matchesPatterns(normalized, includePatterns))
+            return;
+        queued.add(normalized);
+        queue.push({ url: normalized, depth });
+    };
+    enqueue(canonicalHost, 0);
+    (site.keyURLs || []).forEach((entry) => {
+        if (entry?.url) {
+            const absolute = (0, helpers_1.safeUrl)(entry.url, canonicalHost);
+            if (absolute)
+                enqueue(absolute, 0);
+        }
+    });
+    try {
+        const sitemapResponse = await fetchWithTimeout(sitemapURL, timeoutMs);
+        if (sitemapResponse.ok) {
+            const sitemapXML = await sitemapResponse.text();
+            extractSitemapURLs(sitemapXML).forEach((url) => {
+                const absolute = (0, helpers_1.safeUrl)(url, canonicalHost);
+                if (absolute)
+                    enqueue(absolute, 0);
+            });
+        }
+    }
+    catch (error) {
+        console.warn('SEO audit sitemap fetch failed:', error);
+    }
+    while (queue.length > 0 && pages.length < maxPages) {
+        const current = queue.shift();
+        if (!current)
+            continue;
+        if (visited.has(current.url))
+            continue;
+        visited.add(current.url);
+        try {
+            const response = await fetchWithTimeout(current.url, timeoutMs);
+            const contentType = response.headers.get('content-type') || '';
+            if (!contentType.toLowerCase().includes('text/html'))
+                continue;
+            const html = await response.text();
+            const parsed = new URL(current.url);
+            pages.push({
+                url: current.url,
+                path: parsed.pathname || '/',
+                statusCode: response.status,
+                html,
+            });
+            if (current.depth < maxDepth) {
+                const links = extractInternalLinks(html, origin);
+                links.forEach((link) => enqueue(link, current.depth + 1));
+            }
+        }
+        catch (error) {
+            console.warn(`SEO audit fetch failed for ${current.url}:`, error);
+        }
+    }
+    return { pages, visitedCount: visited.size };
+};
+exports.crawlSiteForSEO = crawlSiteForSEO;

package/dist/utilities/gsc.d.ts

@@ -0,0 +1,15 @@
+import type { Payload } from 'payload';
+import type { SEOSiteRecord } from '../utilities/types';
+export declare const syncGSCKeywordVisibility: ({ payload, site, }: {
+    payload: Payload;
+    site: SEOSiteRecord;
+}) => Promise<{
+    imported: number;
+    enabled: boolean;
+    skipped?: undefined;
+} | {
+    imported: number;
+    enabled: boolean;
+    skipped: string;
+}>;
+//# sourceMappingURL=gsc.d.ts.map

package/dist/utilities/gsc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gsc.d.ts","sourceRoot":"","sources":["../../src/utilities/gsc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AASvD,eAAO,MAAM,wBAAwB,GAAU,oBAG5C;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,aAAa,CAAA;CACpB;;;;;;;;EA+DA,CAAA"}

package/dist/utilities/gsc.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncGSCKeywordVisibility = void 0;
+const googleapis_1 = require("googleapis");
+const requiredEnv = () => ({
+    clientID: process.env.SEO_GSC_CLIENT_ID,
+    clientSecret: process.env.SEO_GSC_CLIENT_SECRET,
+    redirectURI: process.env.SEO_GSC_REDIRECT_URI,
+    refreshToken: process.env.SEO_GSC_REFRESH_TOKEN,
+});
+const syncGSCKeywordVisibility = async ({ payload, site, }) => {
+    if (site.integrations?.enableSearchConsole !== true) {
+        return { imported: 0, enabled: false };
+    }
+    const env = requiredEnv();
+    if (!env.clientID || !env.clientSecret || !env.redirectURI || !env.refreshToken || !site.canonicalHost) {
+        return { imported: 0, enabled: true, skipped: 'missing-config' };
+    }
+    try {
+        const oauth2Client = new googleapis_1.google.auth.OAuth2(env.clientID, env.clientSecret, env.redirectURI);
+        oauth2Client.setCredentials({
+            refresh_token: env.refreshToken,
+        });
+        const searchConsole = googleapis_1.google.searchconsole({ version: 'v1', auth: oauth2Client });
+        const endDate = new Date();
+        const startDate = new Date();
+        startDate.setDate(endDate.getDate() - 7);
+        const toISODate = (value) => value.toISOString().slice(0, 10);
+        const response = await searchConsole.searchanalytics.query({
+            siteUrl: site.canonicalHost,
+            requestBody: {
+                startDate: toISODate(startDate),
+                endDate: toISODate(endDate),
+                dimensions: ['query', 'page'],
+                rowLimit: 250,
+            },
+        });
+        const rows = response.data.rows || [];
+        let imported = 0;
+        for (const row of rows) {
+            const keys = row.keys || [];
+            const query = keys[0];
+            const page = keys[1];
+            if (!query || !page)
+                continue;
+            await payload.create({
+                collection: 'seo-keyword-visibility',
+                data: {
+                    capturedAt: endDate.toISOString(),
+                    query,
+                    page,
+                    impressions: row.impressions ?? undefined,
+                    clicks: row.clicks ?? undefined,
+                    ctr: row.ctr ?? undefined,
+                    position: row.position ?? undefined,
+                    source: 'gsc',
+                },
+                overrideAccess: true,
+            });
+            imported += 1;
+        }
+        return { imported, enabled: true };
+    }
+    catch (error) {
+        console.warn('GSC sync failed:', error);
+        return { imported: 0, enabled: true, skipped: 'request-failed' };
+    }
+};
+exports.syncGSCKeywordVisibility = syncGSCKeywordVisibility;

package/dist/utilities/helpers.d.ts

@@ -0,0 +1,7 @@
+import type { SEOIssue, SEOIssueSeverity } from '../utilities/types';
+export declare const severityWeights: Record<SEOIssueSeverity, number>;
+export declare const safeUrl: (value: string, fallbackOrigin: string) => string | null;
+export declare const normalizeURL: (value: string) => string;
+export declare const createIssueFingerprint: (url: string, ruleID: string, message: string) => string;
+export declare const countIssuesBySeverity: (issues: SEOIssue[]) => Record<SEOIssueSeverity, number>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/utilities/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/utilities/helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAEpE,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAM5D,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,OAAO,MAAM,EAAE,gBAAgB,MAAM,kBAM5D,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,WAWzC,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAI,KAAK,MAAM,EAAE,QAAQ,MAAM,EAAE,SAAS,MAAM,WACU,CAAA;AAE7F,eAAO,MAAM,qBAAqB,GAAI,QAAQ,QAAQ,EAAE,qCAOrD,CAAA"}

package/dist/utilities/helpers.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countIssuesBySeverity = exports.createIssueFingerprint = exports.normalizeURL = exports.safeUrl = exports.severityWeights = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+exports.severityWeights = {
+    critical: 22,
+    high: 14,
+    medium: 8,
+    low: 4,
+    info: 1,
+};
+const safeUrl = (value, fallbackOrigin) => {
+    try {
+        return new URL(value, fallbackOrigin).toString();
+    }
+    catch {
+        return null;
+    }
+};
+exports.safeUrl = safeUrl;
+const normalizeURL = (value) => {
+    try {
+        const parsed = new URL(value);
+        parsed.hash = '';
+        if ((parsed.protocol === 'http:' && parsed.port === '80') || (parsed.protocol === 'https:' && parsed.port === '443')) {
+            parsed.port = '';
+        }
+        return parsed.toString().replace(/\/$/, '') || parsed.origin;
+    }
+    catch {
+        return value;
+    }
+};
+exports.normalizeURL = normalizeURL;
+const createIssueFingerprint = (url, ruleID, message) => crypto_1.default.createHash('sha1').update(`${(0, exports.normalizeURL)(url)}|${ruleID}|${message}`).digest('hex');
+exports.createIssueFingerprint = createIssueFingerprint;
+const countIssuesBySeverity = (issues) => issues.reduce((acc, issue) => {
+    acc[issue.severity] += 1;
+    return acc;
+}, { critical: 0, high: 0, medium: 0, low: 0, info: 0 });
+exports.countIssuesBySeverity = countIssuesBySeverity;

package/dist/utilities/pagespeed.d.ts

@@ -0,0 +1,3 @@
+import type { SEOPageSpeedSummary } from '../utilities/types';
+export declare const getPageSpeedSummary: (urls: string[]) => Promise<SEOPageSpeedSummary | null>;
+//# sourceMappingURL=pagespeed.d.ts.map

package/dist/utilities/pagespeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagespeed.d.ts","sourceRoot":"","sources":["../../src/utilities/pagespeed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AA2B7D,eAAO,MAAM,mBAAmB,GAAU,MAAM,MAAM,EAAE,KAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CA4B5F,CAAA"}

package/dist/utilities/pagespeed.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageSpeedSummary = void 0;
+const fetchPageSpeedForURL = async (url, apiKey) => {
+    const endpoint = new URL('https://www.googleapis.com/pagespeedonline/v5/runPagespeed');
+    endpoint.searchParams.set('url', url);
+    endpoint.searchParams.set('strategy', 'mobile');
+    endpoint.searchParams.set('key', apiKey);
+    const response = await fetch(endpoint.toString(), { cache: 'no-store' });
+    if (!response.ok) {
+        throw new Error(`PageSpeed request failed with status ${response.status}`);
+    }
+    const json = (await response.json());
+    const lighthouseScore = Number(json?.lighthouseResult?.categories?.performance?.score ?? 0);
+    const metrics = json?.loadingExperience?.metrics || {};
+    const lcp = Number(metrics?.LARGEST_CONTENTFUL_PAINT_MS?.percentile ?? 0);
+    const clsRaw = Number(metrics?.CUMULATIVE_LAYOUT_SHIFT_SCORE?.percentile ?? 0);
+    const cls = clsRaw > 0 ? clsRaw / 100 : 0;
+    return {
+        performanceScore: lighthouseScore > 0 ? Math.round(lighthouseScore * 100) : undefined,
+        lcpMs: lcp > 0 ? lcp : undefined,
+        cls: cls > 0 ? Number(cls.toFixed(3)) : undefined,
+    };
+};
+const getPageSpeedSummary = async (urls) => {
+    const apiKey = process.env.SEO_PAGESPEED_API_KEY;
+    if (!apiKey || urls.length === 0)
+        return null;
+    const sampled = urls.slice(0, 5);
+    const results = await Promise.allSettled(sampled.map((url) => fetchPageSpeedForURL(url, apiKey)));
+    const successful = results
+        .filter((result) => result.status === 'fulfilled')
+        .map((result) => result.value);
+    if (!successful.length)
+        return null;
+    const performance = successful.map((entry) => entry.performanceScore).filter((value) => typeof value === 'number');
+    const lcps = successful.map((entry) => entry.lcpMs).filter((value) => typeof value === 'number');
+    const clsValues = successful.map((entry) => entry.cls).filter((value) => typeof value === 'number');
+    const average = (values) => values.length ? Math.round(values.reduce((sum, value) => sum + value, 0) / values.length) : undefined;
+    const averageCLS = clsValues.length
+        ? Number((clsValues.reduce((sum, value) => sum + value, 0) / clsValues.length).toFixed(3))
+        : undefined;
+    return {
+        averagePerformanceScore: average(performance),
+        averageLCPMs: average(lcps),
+        averageCLS,
+    };
+};
+exports.getPageSpeedSummary = getPageSpeedSummary;

package/dist/utilities/providers.d.ts

@@ -0,0 +1,3 @@
+import type { SEOProviderAdapter } from '../utilities/types';
+export declare const getSEOProviderAdapter: () => SEOProviderAdapter;
+//# sourceMappingURL=providers.d.ts.map

package/dist/utilities/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/utilities/providers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAY5D,eAAO,MAAM,qBAAqB,QAAO,kBAMxC,CAAA"}

package/dist/utilities/providers.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSEOProviderAdapter = void 0;
+const manualProvider = {
+    name: 'manual',
+    isConfigured: () => true,
+};
+const externalProvider = {
+    name: process.env.SEO_PROVIDER || 'none',
+    isConfigured: () => Boolean(process.env.SEO_PROVIDER && process.env.SEO_PROVIDER_API_KEY),
+};
+const getSEOProviderAdapter = () => {
+    if (externalProvider.isConfigured()) {
+        return externalProvider;
+    }
+    return manualProvider;
+};
+exports.getSEOProviderAdapter = getSEOProviderAdapter;

package/dist/utilities/runAudit.d.ts

@@ -0,0 +1,14 @@
+import type { Payload } from 'payload';
+import type { SEOAuditRunType, SEOSiteRecord } from '../utilities/types';
+export declare const enforceSEORetention: (payload: Payload, keepSnapshots?: number) => Promise<void>;
+export declare const runSEOSnapshot: ({ payload, site, runType, }: {
+    payload: Payload;
+    site: SEOSiteRecord;
+    runType: SEOAuditRunType;
+}) => Promise<{
+    snapshotID: number | string;
+    pagesChecked: number;
+    overallScore: number;
+    issueCounts: Record<import("../utilities/types").SEOIssueSeverity, number>;
+}>;
+//# sourceMappingURL=runAudit.d.ts.map

package/dist/utilities/runAudit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runAudit.d.ts","sourceRoot":"","sources":["../../src/utilities/runAudit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAQtC,OAAO,KAAK,EAAE,eAAe,EAA2B,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAqDjG,eAAO,MAAM,mBAAmB,GAAU,SAAS,OAAO,EAAE,sBAAkB,kBAqC7E,CAAA;AAED,eAAO,MAAM,cAAc,GAAU,6BAIlC;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,aAAa,CAAA;IACnB,OAAO,EAAE,eAAe,CAAA;CACzB;gBAoIyC,MAAM,GAAG,MAAM;;;;EAmBxD,CAAA"}

package/dist/utilities/runAudit.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSEOSnapshot = exports.enforceSEORetention = void 0;
+const checks_1 = require("../utilities/checks");
+const crawler_1 = require("../utilities/crawler");
+const helpers_1 = require("../utilities/helpers");
+const gsc_1 = require("../utilities/gsc");
+const pagespeed_1 = require("../utilities/pagespeed");
+const scoring_1 = require("../utilities/scoring");
+const providers_1 = require("../utilities/providers");
+const average = (values) => {
+    if (!values.length)
+        return 0;
+    return Math.round(values.reduce((sum, value) => sum + value, 0) / values.length);
+};
+const applyPerformanceIssues = (issues, pageSpeed, site) => {
+    if (!pageSpeed)
+        return issues;
+    const nextIssues = [...issues];
+    if (typeof pageSpeed.averagePerformanceScore === 'number' && pageSpeed.averagePerformanceScore < 70) {
+        nextIssues.push({
+            fingerprint: `perf-score-${pageSpeed.averagePerformanceScore}`,
+            ruleID: 'pagespeed-performance-low',
+            category: 'performance',
+            severity: pageSpeed.averagePerformanceScore < 50 ? 'high' : 'medium',
+            message: `Average Lighthouse performance score is ${pageSpeed.averagePerformanceScore}.`,
+            recommendation: 'Optimize render-blocking assets, image delivery, and JS execution.',
+        });
+    }
+    const targetLCP = Number(site.thresholds?.targetLCPMs || 2500);
+    if (typeof pageSpeed.averageLCPMs === 'number' && pageSpeed.averageLCPMs > targetLCP) {
+        nextIssues.push({
+            fingerprint: `perf-lcp-${pageSpeed.averageLCPMs}`,
+            ruleID: 'pagespeed-lcp-high',
+            category: 'performance',
+            severity: pageSpeed.averageLCPMs > targetLCP * 1.5 ? 'high' : 'medium',
+            message: `Average LCP is ${pageSpeed.averageLCPMs}ms.`,
+            recommendation: 'Improve server response times, preload key assets, and optimize hero content.',
+        });
+    }
+    const targetCLS = Number(site.thresholds?.targetCLS || 0.1);
+    if (typeof pageSpeed.averageCLS === 'number' && pageSpeed.averageCLS > targetCLS) {
+        nextIssues.push({
+            fingerprint: `perf-cls-${pageSpeed.averageCLS}`,
+            ruleID: 'pagespeed-cls-high',
+            category: 'performance',
+            severity: pageSpeed.averageCLS > targetCLS * 2 ? 'high' : 'medium',
+            message: `Average CLS is ${pageSpeed.averageCLS}.`,
+            recommendation: 'Set explicit media dimensions and reduce layout shifts from dynamic UI elements.',
+        });
+    }
+    return nextIssues;
+};
+const enforceSEORetention = async (payload, keepSnapshots = 16) => {
+    const snapshots = await payload.find({
+        collection: 'seo-snapshots',
+        where: {},
+        limit: 200,
+        sort: '-startedAt',
+        depth: 0,
+        overrideAccess: true,
+    });
+    const excess = snapshots.docs.slice(keepSnapshots);
+    if (!excess.length)
+        return;
+    for (const snapshot of excess) {
+        const snapshotID = snapshot.id;
+        const pageResults = await payload.find({
+            collection: 'seo-page-results',
+            where: { snapshot: { equals: snapshotID } },
+            limit: 5000,
+            depth: 0,
+            overrideAccess: true,
+        });
+        for (const pageResult of pageResults.docs) {
+            await payload.delete({
+                collection: 'seo-page-results',
+                id: pageResult.id,
+                overrideAccess: true,
+            });
+        }
+        await payload.delete({
+            collection: 'seo-snapshots',
+            id: snapshotID,
+            overrideAccess: true,
+        });
+    }
+};
+exports.enforceSEORetention = enforceSEORetention;
+const runSEOSnapshot = async ({ payload, site, runType, }) => {
+    const runLabel = `${site.name || 'Site'} SEO Snapshot ${new Date().toISOString()}`;
+    const snapshot = await payload.create({
+        collection: 'seo-snapshots',
+        data: {
+            runLabel,
+            runType,
+            status: 'pending',
+            startedAt: new Date().toISOString(),
+        },
+        overrideAccess: true,
+    });
+    try {
+        const crawl = await (0, crawler_1.crawlSiteForSEO)(site);
+        const pageResults = crawl.pages.map((page) => {
+            const check = (0, checks_1.runSEOChecks)(page.url, page.html);
+            const score = (0, scoring_1.scoreSEOIssues)(check.issues);
+            return {
+                url: page.url,
+                path: page.path,
+                statusCode: page.statusCode,
+                check,
+                score,
+            };
+        });
+        const pageSpeedSummary = site.integrations?.enablePageSpeed !== false
+            ? await (0, pagespeed_1.getPageSpeedSummary)(pageResults.map((page) => page.url))
+            : null;
+        const allIssues = applyPerformanceIssues(pageResults.flatMap((result) => result.check.issues), pageSpeedSummary, site);
+        const issueCounts = (0, helpers_1.countIssuesBySeverity)(allIssues);
+        const providerAdapter = (0, providers_1.getSEOProviderAdapter)();
+        const keywordVisibilitySync = await (0, gsc_1.syncGSCKeywordVisibility)({
+            payload,
+            site,
+        });
+        const summaryText = keywordVisibilitySync.enabled
+            ? `Automated audit completed using ${providerAdapter.name} authority adapter. GSC rows imported: ${keywordVisibilitySync.imported}.`
+            : `Automated audit completed using ${providerAdapter.name} authority adapter.`;
+        const scores = {
+            metadata: average(pageResults.map((result) => result.score.metadata)),
+            indexability: average(pageResults.map((result) => result.score.indexability)),
+            structure: average(pageResults.map((result) => result.score.structure)),
+            links: average(pageResults.map((result) => result.score.links)),
+            media: average(pageResults.map((result) => result.score.media)),
+            structuredData: average(pageResults.map((result) => result.score.structuredData)),
+            performance: typeof pageSpeedSummary?.averagePerformanceScore === 'number'
+                ? pageSpeedSummary.averagePerformanceScore
+                : average(pageResults.map((result) => result.score.performance)),
+        };
+        const overallScore = Math.round(scores.metadata * 0.2 +
+            scores.indexability * 0.2 +
+            scores.structure * 0.15 +
+            scores.links * 0.1 +
+            scores.media * 0.1 +
+            scores.structuredData * 0.1 +
+            scores.performance * 0.15);
+        for (const result of pageResults) {
+            await payload.create({
+                collection: 'seo-page-results',
+                data: {
+                    snapshot: snapshot.id,
+                    url: result.url,
+                    path: result.path,
+                    statusCode: result.statusCode,
+                    title: result.check.title,
+                    metaDescription: result.check.metaDescription,
+                    canonical: result.check.canonical,
+                    robotsMeta: result.check.robotsMeta,
+                    h1Count: result.check.h1Count,
+                    headingOrderIssues: result.check.headingOrderIssues,
+                    internalLinks: result.check.internalLinks,
+                    externalLinks: result.check.externalLinks,
+                    imagesTotal: result.check.imagesTotal,
+                    imagesMissingAlt: result.check.imagesMissingAlt,
+                    structuredDataBlocks: result.check.structuredDataBlocks,
+                    scoreBreakdown: {
+                        metadata: result.score.metadata,
+                        indexability: result.score.indexability,
+                        structure: result.score.structure,
+                        links: result.score.links,
+                        media: result.score.media,
+                        structuredData: result.score.structuredData,
+                    },
+                    overallScore: result.score.overall,
+                    issues: result.check.issues,
+                    checkedAt: new Date().toISOString(),
+                },
+                overrideAccess: true,
+            });
+        }
+        await payload.update({
+            collection: 'seo-snapshots',
+            id: snapshot.id,
+            data: {
+                status: 'completed',
+                completedAt: new Date().toISOString(),
+                metrics: {
+                    pagesCrawled: crawl.visitedCount,
+                    pagesChecked: pageResults.length,
+                    avgLighthousePerformance: pageSpeedSummary?.averagePerformanceScore,
+                    avgLCPMs: pageSpeedSummary?.averageLCPMs,
+                    avgCLS: pageSpeedSummary?.averageCLS,
+                },
+                issueCounts,
+                scores: {
+                    ...scores,
+                    overall: overallScore,
+                },
+                summary: summaryText,
+            },
+            overrideAccess: true,
+        });
+        await (0, exports.enforceSEORetention)(payload);
+        return {
+            snapshotID: snapshot.id,
+            pagesChecked: pageResults.length,
+            overallScore,
+            issueCounts,
+        };
+    }
+    catch (error) {
+        await payload.update({
+            collection: 'seo-snapshots',
+            id: snapshot.id,
+            data: {
+                status: 'failed',
+                completedAt: new Date().toISOString(),
+                errorMessage: error instanceof Error ? error.message : String(error),
+            },
+            overrideAccess: true,
+        });
+        throw error;
+    }
+};
+exports.runSEOSnapshot = runSEOSnapshot;

package/dist/utilities/scoring.d.ts

@@ -0,0 +1,3 @@
+import type { SEOIssue, SEOPageScore } from '../utilities/types';
+export declare const scoreSEOIssues: (issues: SEOIssue[]) => SEOPageScore;
+//# sourceMappingURL=scoring.d.ts.map

package/dist/utilities/scoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoring.d.ts","sourceRoot":"","sources":["../../src/utilities/scoring.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAoB,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAmBlF,eAAO,MAAM,cAAc,GAAI,QAAQ,QAAQ,EAAE,KAAG,YA8BnD,CAAA"}