@prenta/core 4.1.0 → 4.2.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @actuate-media/cms-core
 
+## 4.2.0
+
+### Minor Changes
+
+- 2ff1c74: Approve-gated internal link insert and orphan-page execute, with verify-before-resolve.
+
+## 4.1.1
+
+### Patch Changes
+
+- b86fa37: Accept slash-separated nested slugs (help/faq) and label the published-page save as Update live.
+
 ## 4.1.0
 
 ### Minor Changes

package/dist/api/routes/seo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seo.d.ts","sourceRoot":"","sources":["../../../src/api/routes/seo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AA4G7C,+EAA+E;AAC/E,wBAAgB,oBAAoB,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,EAC7F,MAAM,EAAE,CAAC,EAAE,GACV,CAAC,EAAE,CAQL;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAi8EzD"}
+{"version":3,"file":"seo.d.ts","sourceRoot":"","sources":["../../../src/api/routes/seo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAgG7C,+EAA+E;AAC/E,wBAAgB,oBAAoB,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,EAC7F,MAAM,EAAE,CAAC,EAAE,GACV,CAAC,EAAE,CAQL;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAquFzD"}

package/dist/api/routes/seo.js

@@ -4,7 +4,7 @@ import { DEFAULT_DIRECTIVES, coerceMaxImagePreview } from '../../seo/robots-dire
 import { processSeoScan } from '../../cron/index.js';
 import { isResolvedIp } from '../../security/client-ip.js';
 import { classifyLinkHealthIssue, extractOutboundUrlsFromDocumentData, probeOutboundLink, } from '../../seo/link-probe.js';
-import { resolveTrailingSlashPolicy, trailingSlashMismatchTarget } from '../../seo/document-path.js';
+import { documentPublicPath, resolveTrailingSlashPolicy, trailingSlashMismatchTarget, } from '../../seo/document-path.js';
 import { getPrentaConfig } from '../../config/runtime.js';
 import { assertPlanFeature, hasPlanFeature } from '../../plan/features.js';
 import { extraImagesForSeoAnalysis, firstSectionHeading } from '../../seo/document-content.js';
@@ -13,6 +13,8 @@ import { guardedDb } from '../guarded-db.js';
 import { recordAiCrawlerFromRequest, recordAiCrawlerHit } from '../../seo/ai-crawler-log.js';
 import { detectAiBot } from '../../seo/ai-bots.js';
 import { json, errorResponse, internalError, asRecord, normalizeSeoPage, hasModel, formatCompactNumber, modelNotAvailable, requireAuth, buildActionContext, WRITE_ROLES, ADMIN_ROLES, requireRole, linkHealthLimiter, seoAuditLimiter, aiGenerateLimiter, checkRateLimitAsync, clientIp, enforceDocumentReadAccess, importAIPlugin, } from '../route-helpers.js';
+import { gatherNavigationLinkTargets } from '../../seo/nav-link-targets.js';
+import { suggestInboundLinks } from '../../seo/link-suggest.js';
 // Explicit risk order. A plain `severity: 'asc'` DB sort orders the values
 // alphabetically (critical, info, warning) which wrongly ranks `info` above
 // `warning`. Unknown severities sort last.
@@ -20,43 +22,6 @@ const SEVERITY_RANK = { critical: 0, warning: 1, info: 2 };
 function severityRank(severity) {
     return SEVERITY_RANK[String(severity)] ?? 99;
 }
-/**
- * Collect internal link targets from global navigation menus (the `navigations`
- * collection) so the link-graph can treat nav-linked pages as non-orphaned.
- * Best-effort: returns `[]` when the navigation plugin isn't installed or on any
- * read error.
- */
-async function gatherNavigationLinkTargets(db) {
-    try {
-        if (!hasModel(db, 'document'))
-            return [];
-        const { coercePublicNavItems } = await import('../../site.js');
-        const navDocs = await db.document
-            .findMany({
-            where: { collection: 'navigations', deletedAt: null, status: { not: 'ARCHIVED' } },
-            select: { data: true },
-            take: 50,
-        })
-            .catch(() => []);
-        const targets = [];
-        const walk = (items) => {
-            for (const item of items) {
-                if (typeof item.url === 'string' && item.url.trim())
-                    targets.push(item.url);
-                if (item.children)
-                    walk(item.children);
-            }
-        };
-        for (const doc of navDocs) {
-            const data = doc?.data && typeof doc.data === 'object' ? doc.data : {};
-            walk(coercePublicNavItems(data.items));
-        }
-        return targets;
-    }
-    catch {
-        return [];
-    }
-}
 function planRequiredResponse(denial) {
     return json({
         error: denial.message,
@@ -65,6 +30,23 @@ function planRequiredResponse(denial) {
         feature: denial.feature,
     }, 403);
 }
+function mapInternalLinkInsertError(err) {
+    const msg = err instanceof Error ? err.message : '';
+    switch (msg) {
+        case 'SOURCE_NOT_FOUND':
+            return errorResponse('Source document not found', 404);
+        case 'TARGET_NOT_FOUND':
+            return errorResponse('Target document not found', 404);
+        case 'NOT_WRAPPABLE':
+            return errorResponse('Anchor is not wrappable in the live source document.', 422);
+        case 'ALREADY_LINKED':
+            return errorResponse('Source already links to this target.', 422);
+        case 'TARGET_PATH_MISMATCH':
+            return errorResponse('Target path does not match the live document.', 422);
+        default:
+            return null;
+    }
+}
 function seoAiGenerationError(result) {
     if (result.code === 'unavailable' || result.code === 'feature_disabled') {
         return errorResponse(result.message, 503);
@@ -352,76 +334,25 @@ export function registerSeoRoutes(router) {
                 return errorResponse('targetEntityId and targetEntityType are required', 400);
             }
             const limit = Math.max(1, Math.min(20, typeof body.limit === 'number' ? body.limit : 8));
-            const { gatherAuditEntities, frontEndContentCollectionTypes } = await import('../../seo/audit-runner.js');
-            const cfg = getPrentaConfig();
-            const collectionTypes = frontEndContentCollectionTypes(cfg);
-            const entities = await gatherAuditEntities(db(), { collectionTypes });
-            const target = entities.find((e) => e.entityId === body.targetEntityId);
-            if (!target)
-                return errorResponse('Target document not found in link graph', 404);
-            const sources = entities.filter((e) => e.entityId !== target.entityId);
-            const query = [target.title, target.focusKeyword, target.metaDescription]
-                .filter(Boolean)
-                .join(' — ');
-            const docRows = await db()
-                .document.findMany({
-                where: { id: { in: sources.map((s) => s.entityId) } },
-                select: { id: true, collection: true },
-            })
-                .catch(() => []);
-            const collections = Object.fromEntries(docRows.map((d) => [d.id, d.collection]));
-            let suggestions = [];
+            let result;
             try {
-                const aiModule = await importAIPlugin();
-                if (typeof aiModule?.semanticSearch === 'function') {
-                    const corpus = sources.map((s) => ({
-                        id: s.entityId,
-                        collectionSlug: collections[s.entityId] ?? 'pages',
-                        title: s.title,
-                        content: (s.content ?? '').slice(0, 8000),
-                    }));
-                    const results = await aiModule.semanticSearch(query, { limit, threshold: 0.35, corpus });
-                    suggestions = results.map((r) => ({
-                        sourceEntityId: r.id,
-                        sourceTitle: r.title,
-                        sourceUrl: sources.find((s) => s.entityId === r.id)?.url ?? '',
-                        anchorText: target.title,
-                        confidence: Math.round(r.score * 100) / 100,
-                        excerpt: r.excerpt,
-                    }));
-                }
-                else if (typeof aiModule?.suggestInternalLinks === 'function') {
-                    for (const source of sources.slice(0, 40)) {
-                        const found = await aiModule.suggestInternalLinks(source.content ?? '', [
-                            {
-                                id: target.entityId,
-                                title: target.title,
-                                url: target.url,
-                                keywords: target.focusKeyword ? [target.focusKeyword] : [],
-                            },
-                        ]);
-                        for (const f of found.slice(0, 2)) {
-                            suggestions.push({
-                                sourceEntityId: source.entityId,
-                                sourceTitle: source.title,
-                                sourceUrl: source.url,
-                                anchorText: f.anchorText,
-                                confidence: f.confidence,
-                                excerpt: (source.content ?? '').slice(f.position.start, f.position.end + 40),
-                            });
-                        }
-                    }
-                    suggestions.sort((a, b) => b.confidence - a.confidence);
-                    suggestions = suggestions.slice(0, limit);
-                }
+                result = await suggestInboundLinks({
+                    db: db(),
+                    targetEntityId: body.targetEntityId,
+                    targetEntityType: body.targetEntityType,
+                    limit,
+                });
             }
-            catch {
-                suggestions = [];
+            catch (err) {
+                if (err instanceof Error && err.message === 'TARGET_NOT_FOUND') {
+                    return errorResponse('Target document not found in link graph', 404);
+                }
+                throw err;
             }
             return json({
                 data: {
-                    target: { id: target.entityId, title: target.title, url: target.url },
-                    suggestions,
+                    target: result.target,
+                    suggestions: result.suggestions,
                 },
             });
         }
@@ -429,6 +360,124 @@ export function registerSeoRoutes(router) {
             return internalError(err, 'seo/links/suggest');
         }
     });
+    router.post('/seo/links/apply', async (request) => {
+        try {
+            const auth = await requireAuth(request);
+            if (auth.error)
+                return auth.error;
+            const roleErr = requireRole(auth.session.role, WRITE_ROLES);
+            if (roleErr)
+                return roleErr;
+            const inlinePlanErr = assertPlanFeature('seo.inlineApply');
+            if (inlinePlanErr)
+                return planRequiredResponse(inlinePlanErr);
+            if (!(await checkRateLimitAsync(aiGenerateLimiter, `link-apply:${auth.session.userId}`))) {
+                return errorResponse('Link apply rate limit reached. Try again later.', 429);
+            }
+            const body = (await request.json().catch(() => ({})));
+            const sourceEntityId = typeof body?.sourceEntityId === 'string' ? body.sourceEntityId.trim() : '';
+            const targetEntityId = typeof body?.targetEntityId === 'string' ? body.targetEntityId.trim() : '';
+            const anchorText = typeof body?.anchorText === 'string' ? body.anchorText : '';
+            const fingerprint = typeof body?.fingerprint === 'string' ? body.fingerprint : '';
+            if (!sourceEntityId || !targetEntityId || !anchorText.trim() || !fingerprint) {
+                return errorResponse('sourceEntityId, targetEntityId, anchorText, and fingerprint are required', 400);
+            }
+            const source = await db().document.findFirst({
+                where: { id: sourceEntityId, deletedAt: null },
+                select: {
+                    id: true,
+                    collection: true,
+                    updatedAt: true,
+                    data: true,
+                    slug: true,
+                    status: true,
+                },
+            });
+            if (!source)
+                return errorResponse('Source document not found', 404);
+            const target = await db().document.findFirst({
+                where: { id: targetEntityId, deletedAt: null },
+                select: { id: true, collection: true, data: true, slug: true, status: true },
+            });
+            if (!target)
+                return errorResponse('Target document not found', 404);
+            const targetData = asRecord(target.data);
+            const targetSlug = (typeof targetData.slug === 'string' && targetData.slug) ||
+                (typeof target.slug === 'string' && target.slug) ||
+                target.id;
+            const collectionDef = getPrentaConfig()?.collections?.[target.collection];
+            const targetPath = documentPublicPath({
+                urlPrefix: collectionDef?.urlPrefix,
+                slug: targetSlug,
+                data: targetData,
+            });
+            const { applyAndVerifyInternalLinkInsert, buildInsertLinkFingerprint } = await import('../../seo/issue-fix-link-insert.js');
+            const liveFingerprint = buildInsertLinkFingerprint(sourceEntityId, targetEntityId, anchorText, source.updatedAt instanceof Date ? source.updatedAt : new Date(source.updatedAt));
+            if (fingerprint !== liveFingerprint) {
+                return errorResponse('This fix is stale — the page changed since the suggestion was loaded. Expand the row again.', 409);
+            }
+            const ctx = buildActionContext(auth.session, db());
+            let verified;
+            try {
+                const result = await applyAndVerifyInternalLinkInsert({
+                    db: db(),
+                    ctx,
+                    sourceEntityId,
+                    targetEntityId,
+                    anchorText,
+                    targetPath,
+                    siteUrl: getPrentaConfig()?.seo?.siteUrl ?? '',
+                    navLinks: await gatherNavigationLinkTargets(db()),
+                });
+                verified = result.verify;
+            }
+            catch (err) {
+                const mapped = mapInternalLinkInsertError(err);
+                if (mapped)
+                    return mapped;
+                throw err;
+            }
+            if (!verified.ok) {
+                return json({ error: 'Fix applied but verification failed.', reason: verified.reason }, 409);
+            }
+            if (hasModel(db(), 'seoIssue')) {
+                await db().seoIssue.updateMany({
+                    where: {
+                        type: 'orphan-page',
+                        entityId: targetEntityId,
+                        status: { in: ['open', 'recurring'] },
+                    },
+                    data: {
+                        status: 'resolved',
+                        resolvedAt: new Date(),
+                        resolvedById: auth.session.userId,
+                    },
+                });
+            }
+            try {
+                await logEvent({
+                    event: 'document_updated',
+                    userId: auth.session.userId,
+                    details: {
+                        action: 'seo_internal_link_applied',
+                        seoFix: 'insert-link',
+                        sourceEntityId,
+                        targetEntityId,
+                        targetPath,
+                    },
+                });
+            }
+            catch {
+                /* noop */
+            }
+            return json({
+                data: { sourceEntityId, targetEntityId, targetPath, applied: true },
+            });
+        }
+        catch (err) {
+            return internalError(err, 'seo/links/apply');
+        }
+    });
     router.post('/seo/scan', async (request) => {
         try {
             const auth = await requireAuth(request);
@@ -1295,7 +1344,8 @@ export function registerSeoRoutes(router) {
             };
             let aiDeps;
             const { REDIRECT_FIX_TYPES } = await import('../../seo/issue-fix-redirect.js');
-            if (REDIRECT_FIX_TYPES.has(issue.type)) {
+            const { INSERT_LINK_FIX_TYPES } = await import('../../seo/issue-fix-link-insert.js');
+            if (REDIRECT_FIX_TYPES.has(issue.type) || INSERT_LINK_FIX_TYPES.has(issue.type)) {
                 aiDeps = {
                     db: db(),
                     userId: auth.session.userId,
@@ -1365,10 +1415,114 @@ export function registerSeoRoutes(router) {
                 metadata: asRecord(issue.metadata),
             };
             const { REDIRECT_FIX_TYPES, applyBrokenLinkRedirectFix, applyBrokenLinkContentFix } = await import('../../seo/issue-fix-redirect.js');
+            const { pendingFixFromMetadata } = await import('../../seo/issue-fix-ai.js');
+            const { verifySeoIssueFix } = await import('../../seo/issue-fix-verify.js');
+            const { INSERT_LINK_FIX_TYPES, applyAndVerifyInternalLinkInsert, buildInsertLinkFingerprint, } = await import('../../seo/issue-fix-link-insert.js');
+            const cachedPending = pendingFixFromMetadata(issue.metadata);
+            const isInsertLinkFix = INSERT_LINK_FIX_TYPES.has(issue.type) || cachedPending?.patch?.fixStrategy === 'insert-link';
+            if (isInsertLinkFix) {
+                const inlinePlanErr = assertPlanFeature('seo.inlineApply');
+                if (inlinePlanErr)
+                    return planRequiredResponse(inlinePlanErr);
+                if (!cachedPending?.autoFixable ||
+                    (cachedPending.patch.fixStrategy !== 'insert-link' &&
+                        !INSERT_LINK_FIX_TYPES.has(issue.type))) {
+                    return errorResponse('This issue does not support an automatic fix.', 422);
+                }
+                if (INSERT_LINK_FIX_TYPES.has(issue.type) &&
+                    cachedPending.patch.fixStrategy &&
+                    cachedPending.patch.fixStrategy !== 'insert-link') {
+                    return errorResponse('This issue does not support an automatic fix.', 422);
+                }
+                const sourceEntityId = typeof cachedPending.patch.sourceEntityId === 'string'
+                    ? cachedPending.patch.sourceEntityId
+                    : '';
+                const targetEntityId = typeof cachedPending.patch.targetEntityId === 'string'
+                    ? cachedPending.patch.targetEntityId
+                    : (issue.entityId ?? '');
+                const targetPath = typeof cachedPending.patch.targetPath === 'string'
+                    ? cachedPending.patch.targetPath
+                    : loaded.entity.url;
+                const anchorText = typeof cachedPending.patch.anchorText === 'string' ? cachedPending.patch.anchorText : '';
+                if (!sourceEntityId || !targetEntityId || !anchorText) {
+                    return errorResponse('This issue does not support an automatic fix.', 422);
+                }
+                if (body?.fingerprint && body.fingerprint !== cachedPending.fingerprint) {
+                    return errorResponse('This fix is stale — the page changed since the suggestion was loaded. Expand the row again.', 409);
+                }
+                const source = await db().document.findFirst({
+                    where: { id: sourceEntityId, deletedAt: null },
+                    select: { id: true, updatedAt: true },
+                });
+                if (!source)
+                    return errorResponse('Source document not found', 404);
+                const liveFingerprint = buildInsertLinkFingerprint(sourceEntityId, targetEntityId, anchorText, source.updatedAt instanceof Date ? source.updatedAt : new Date(source.updatedAt));
+                if (cachedPending.fingerprint !== liveFingerprint) {
+                    return errorResponse('This fix is stale — the page changed since the suggestion was loaded. Expand the row again.', 409);
+                }
+                const ctx = buildActionContext(auth.session, db());
+                let verified;
+                try {
+                    const result = await applyAndVerifyInternalLinkInsert({
+                        db: db(),
+                        ctx,
+                        sourceEntityId,
+                        targetEntityId,
+                        anchorText,
+                        targetPath,
+                        siteUrl: getPrentaConfig()?.seo?.siteUrl ?? loaded.siteSeo?.siteUrl ?? '',
+                        navLinks: await gatherNavigationLinkTargets(db()),
+                    });
+                    verified = result.verify;
+                }
+                catch (err) {
+                    const mapped = mapInternalLinkInsertError(err);
+                    if (mapped)
+                        return mapped;
+                    throw err;
+                }
+                if (!verified.ok) {
+                    return json({ error: 'Fix applied but verification failed.', reason: verified.reason }, 409);
+                }
+                const existingMeta = asRecord(issue.metadata);
+                const resolved = await db().seoIssue.update({
+                    where: { id: issue.id },
+                    data: {
+                        status: 'resolved',
+                        resolvedAt: new Date(),
+                        resolvedById: auth.session.userId,
+                        relatedEntityIds: [sourceEntityId],
+                        metadata: { ...existingMeta, pendingFix: null },
+                    },
+                });
+                try {
+                    await logEvent({
+                        event: 'document_updated',
+                        userId: auth.session.userId,
+                        details: {
+                            action: 'seo_issue_fix_applied',
+                            seoFix: 'insert-link',
+                            issueId: issue.id,
+                            issueType: issue.type,
+                            sourceEntityId,
+                            targetEntityId,
+                            targetPath,
+                        },
+                    });
+                }
+                catch {
+                    /* noop */
+                }
+                return json({
+                    data: {
+                        issue: seoIssueToApi(resolved),
+                        applied: cachedPending.changes,
+                    },
+                });
+            }
             if (REDIRECT_FIX_TYPES.has(issue.type)) {
-                const { pendingFixFromMetadata } = await import('../../seo/issue-fix-ai.js');
                 const { buildFixFingerprint } = await import('../../seo/issue-fix.js');
-                const cached = pendingFixFromMetadata(issue.metadata);
+                const cached = cachedPending;
                 const liveFingerprint = buildFixFingerprint(loaded.entity.entityId, issue.type, loaded.updatedAt);
                 if (!cached?.autoFixable) {
                     return errorResponse('This issue does not support an automatic fix.', 422);
@@ -1393,6 +1547,31 @@ export function registerSeoRoutes(router) {
                     const msg = err instanceof Error ? err.message : 'Fix application failed';
                     return errorResponse(msg, 400);
                 }
+                const afterDoc = await db().document.findFirst({
+                    where: { id: loaded.entity.entityId, deletedAt: null },
+                    select: { data: true },
+                });
+                const redirectSuggestion = {
+                    autoFixable: true,
+                    fingerprint: cached.fingerprint,
+                    fixStrategy: fixStrategy,
+                    patch: cached.patch,
+                    changes: cached.changes,
+                    justification: cached.justification,
+                    source: cached.source,
+                };
+                const verified = await verifySeoIssueFix({
+                    issueType: issue.type,
+                    suggestion: redirectSuggestion,
+                    entityId: loaded.entity.entityId,
+                    live: { data: asRecord(afterDoc?.data) },
+                    db: db(),
+                    siteUrl: getPrentaConfig()?.seo?.siteUrl ?? loaded.siteSeo?.siteUrl ?? '',
+                    navLinks: await gatherNavigationLinkTargets(db()),
+                });
+                if (!verified.ok) {
+                    return json({ error: 'Fix applied but verification failed.', reason: verified.reason }, 409);
+                }
                 const existingMeta = asRecord(issue.metadata);
                 const resolved = await db().seoIssue.update({
                     where: { id: issue.id },
@@ -1436,14 +1615,13 @@ export function registerSeoRoutes(router) {
                 });
             }
             const { suggestDeterministicFix, buildFixFingerprint } = await import('../../seo/issue-fix.js');
-            const { pendingFixFromMetadata } = await import('../../seo/issue-fix-ai.js');
             const deterministic = suggestDeterministicFix(issueInput, fixCtx);
             let suggestion = deterministic;
             if (!deterministic.autoFixable || Object.keys(deterministic.patch).length === 0) {
                 const inlinePlanErr = assertPlanFeature('seo.inlineApply');
                 if (inlinePlanErr)
                     return planRequiredResponse(inlinePlanErr);
-                const cached = pendingFixFromMetadata(issue.metadata);
+                const cached = cachedPending;
                 const liveFingerprint = buildFixFingerprint(loaded.entity.entityId, issue.type, loaded.updatedAt);
                 if (!cached || !cached.autoFixable) {
                     return errorResponse('This issue does not support an automatic fix.', 422);
@@ -1481,6 +1659,50 @@ export function registerSeoRoutes(router) {
                     return errorResponse('Document not found', 404);
                 throw err;
             }
+            const afterDoc = await db().document.findFirst({
+                where: { id: loaded.entity.entityId, deletedAt: null },
+                select: {
+                    id: true,
+                    collection: true,
+                    title: true,
+                    slug: true,
+                    data: true,
+                    structuredData: true,
+                    plainText: true,
+                    publishedAt: true,
+                    status: true,
+                },
+            });
+            const { documentToAuditEntity, frontEndContentCollectionTypes } = await import('../../seo/audit-runner.js');
+            const liveEntity = afterDoc
+                ? documentToAuditEntity(afterDoc, frontEndContentCollectionTypes(getPrentaConfig()), loaded.siteSeo ?? getPrentaConfig()?.seo)
+                : loaded.entity;
+            // Prefer the rendered/effective meta title so verify matches changes.after
+            // (page-title portion in the patch ≠ rendered title when a template applies).
+            const metaTitleLive = suggestion.changes.some((c) => c.field === 'metaTitle')
+                ? (liveEntity.metaTitle ??
+                    (typeof suggestion.patch.metaTitle === 'string' ? suggestion.patch.metaTitle : null))
+                : (liveEntity.metaTitle ?? null);
+            const verified = await verifySeoIssueFix({
+                issueType: issue.type,
+                suggestion,
+                entityId: loaded.entity.entityId,
+                live: {
+                    data: asRecord(afterDoc?.data),
+                    metaTitle: metaTitleLive,
+                    metaDescription: liveEntity.metaDescription ?? null,
+                    canonical: liveEntity.canonicalUrl ?? null,
+                    noindex: liveEntity.noindex ?? null,
+                    structuredDataType: liveEntity.structuredDataType ?? null,
+                    status: afterDoc ? String(afterDoc.status) : undefined,
+                },
+                db: db(),
+                siteUrl: getPrentaConfig()?.seo?.siteUrl ?? loaded.siteSeo?.siteUrl ?? '',
+                navLinks: await gatherNavigationLinkTargets(db()),
+            });
+            if (!verified.ok) {
+                return json({ error: 'Fix applied but verification failed.', reason: verified.reason }, 409);
+            }
             const existingMeta = asRecord(issue.metadata);
             const resolved = await db().seoIssue.update({
                 where: { id: issue.id },