@prenta/core 0.118.0

package/dist/seo/page-meta.js

@@ -0,0 +1,710 @@
+import { buildSchemaGraph, normalizeOrganizationTypesInJsonLd } from '../content/structured-data.js';
+import { buildNextVerification, buildVerificationMetaEntries, generateMetaTags, generateNextMetadata, renderMetaTagsHtml, renderVerificationMetaHtml, } from './meta-tags.js';
+import { resolveDocumentRobotsDirectives, resolveSeoEnvironment } from './robots.js';
+import { resolveRenderedMetaTitle } from './title-templates.js';
+import { extractAggregateRatingFromSections } from '../sections/widget-embed.js';
+import { resolveDocumentUrl } from './document-path.js';
+export { documentPublicPath, resolveDocumentUrl } from './document-path.js';
+/**
+ * Maps a collection slug to the most appropriate Schema.org type when the
+ * config doesn't specify one. Conservative fallback to WebPage.
+ *
+ * Mirrors `@prenta/plugin-seo` `detectSchemaType()` but is duplicated
+ * here so cms-core has no runtime dependency on the SEO plugin.
+ */
+const SLUG_TO_SCHEMA = {
+    posts: 'BlogPosting',
+    post: 'BlogPosting',
+    blog: 'BlogPosting',
+    articles: 'Article',
+    article: 'Article',
+    news: 'NewsArticle',
+    pages: 'WebPage',
+    page: 'WebPage',
+    team: 'Person',
+    staff: 'Person',
+    author: 'Person',
+    authors: 'Person',
+    events: 'Event',
+    event: 'Event',
+    faq: 'FAQPage',
+    faqs: 'FAQPage',
+    services: 'Service',
+    service: 'Service',
+    jobs: 'JobPosting',
+    careers: 'JobPosting',
+    locations: 'LocalBusiness',
+    location: 'LocalBusiness',
+    testimonials: 'Review',
+    testimonial: 'Review',
+    products: 'Product',
+    product: 'Product',
+    'case-studies': 'Article',
+    'case-study': 'Article',
+    portfolios: 'CreativeWork',
+    portfolio: 'CreativeWork',
+};
+/** Whether `keyTokens` appears as a contiguous run inside `tokens`. */
+function containsTokenRun(tokens, keyTokens) {
+    if (keyTokens.length === 0 || keyTokens.length > tokens.length)
+        return false;
+    for (let i = 0; i <= tokens.length - keyTokens.length; i++) {
+        let match = true;
+        for (let j = 0; j < keyTokens.length; j++) {
+            if (tokens[i + j] !== keyTokens[j]) {
+                match = false;
+                break;
+            }
+        }
+        if (match)
+            return true;
+    }
+    return false;
+}
+function detectSchemaType(collectionSlug) {
+    const normalized = collectionSlug.toLowerCase();
+    if (SLUG_TO_SCHEMA[normalized])
+        return SLUG_TO_SCHEMA[normalized];
+    // Soft match on hyphen/underscore-delimited whole tokens (`blog-posts` →
+    // BlogPosting) — NOT raw substring, which mis-typed `newsletters` → News,
+    // `compost`/`signpost` → BlogPosting, etc. Longest key first so a multi-word
+    // key (`case-studies`) wins over a single-token one.
+    const tokens = normalized.split(/[^a-z0-9]+/).filter(Boolean);
+    const keys = Object.keys(SLUG_TO_SCHEMA).sort((a, b) => b.length - a.length);
+    for (const key of keys) {
+        const keyTokens = key.split(/[^a-z0-9]+/).filter(Boolean);
+        if (containsTokenRun(tokens, keyTokens))
+            return SLUG_TO_SCHEMA[key];
+    }
+    return 'WebPage';
+}
+function trimTrailingSlash(s) {
+    return s.replace(/\/+$/, '');
+}
+/**
+ * Absolutize + normalize an editor-supplied canonical override so it can never
+ * emit a protocol-less / relative / trailing-slash-inconsistent value that
+ * conflicts with `og:url`. Resolves against `siteUrl` (so `about` →
+ * `${siteUrl}/about`), applies the same trailing-slash normalization as
+ * {@link resolveDocumentUrl}, and returns undefined for an unparseable value so
+ * the caller can fall back to the resolved self URL.
+ */
+export function normalizeCanonicalOverride(explicit, siteUrl) {
+    const raw = explicit.trim();
+    if (!raw)
+        return undefined;
+    let resolved;
+    try {
+        resolved = siteUrl ? new URL(raw, `${trimTrailingSlash(siteUrl)}/`) : new URL(raw);
+    }
+    catch {
+        return undefined;
+    }
+    // Strip a trailing slash on non-root paths to match resolveDocumentUrl.
+    if (resolved.pathname !== '/' && resolved.pathname.endsWith('/')) {
+        resolved.pathname = resolved.pathname.replace(/\/+$/, '');
+    }
+    const out = resolved.toString();
+    // Bare origin: resolveDocumentUrl returns it WITHOUT a trailing slash.
+    if (resolved.pathname === '/' && !resolved.search && !resolved.hash) {
+        return trimTrailingSlash(out);
+    }
+    return out;
+}
+/** Split a person's display name into given/family parts for OG profile tags. */
+function resolvePersonNameParts(data, fallbackName) {
+    const first = pickString(data.firstName, data.givenName);
+    const last = pickString(data.lastName, data.familyName, data.surname);
+    if (first || last)
+        return { firstName: first, lastName: last };
+    const full = pickString(data.name, fallbackName);
+    if (!full)
+        return {};
+    const parts = full.trim().split(/\s+/);
+    if (parts.length === 1)
+        return { firstName: parts[0] };
+    return { firstName: parts.slice(0, -1).join(' '), lastName: parts[parts.length - 1] };
+}
+/**
+ * Resolve the canonical URL a document will emit — explicit override or auto
+ * from {@link resolveDocumentUrl}. Matches the fallback used in
+ * `composePageMeta()` so audits and render stay aligned.
+ */
+export function resolveEffectiveCanonicalUrl(params) {
+    const data = params.data ?? {};
+    const page = pageSettingsFromData(data);
+    const explicit = pickString(page.canonical, data.canonical, page.canonicalUrl, data.canonicalUrl);
+    if (explicit)
+        return explicit;
+    return resolveDocumentUrl({
+        siteUrl: params.siteUrl ?? '',
+        urlPrefix: params.urlPrefix,
+        slug: params.slug,
+        data,
+    });
+}
+function pageSettingsFromData(data) {
+    const ps = data._pageSettings ?? data.pageSettings;
+    return ps && typeof ps === 'object' && !Array.isArray(ps) ? ps : {};
+}
+/**
+ * Resolve meta title, description, OG image, and noindex the same way
+ * `composePageMeta()` does — so audits match what search engines receive.
+ */
+export function resolveEffectiveMeta(params) {
+    const data = params.data ?? {};
+    const page = params.pageSettings ?? pageSettingsFromData(data);
+    const site = params.site;
+    const siteUrl = trimTrailingSlash(params.siteUrl ?? site?.siteUrl ?? '');
+    const siteName = site?.siteName ?? 'Site';
+    const collection = params.collection;
+    const collectionSlug = params.collectionSlug ?? collection?.slug ?? '';
+    const collectionSeo = collection?.seo;
+    const schemaType = pickString(page.schemaType, data.schemaType, data.structuredDataType, page.structuredDataType, collectionSeo?.defaultSchemaType) ?? detectSchemaType(collectionSlug);
+    const metaTitlePage = pickString(page.metaTitle, data.metaTitle, data.seoTitle);
+    const rawTitle = pickString(data.title, page.title, params.docTitle) ?? 'Untitled';
+    const metaTitle = resolveRenderedMetaTitle({
+        metaTitlePage,
+        documentTitle: rawTitle,
+        site,
+        vars: siteTitleTemplateVars({
+            data,
+            page,
+            collection,
+            schemaType,
+            publishedAt: params.publishedAt ?? data.publishedAt,
+        }),
+    }) || null;
+    const metaDescription = pickString(page.metaDescription, data.metaDescription, data.seoDescription, page.keyTakeaway, data.keyTakeaway, data.excerpt, data.description, site?.defaultMetaDescription) ?? null;
+    const realImageUrl = pickString(page.ogImage, data.ogImage, asImageUrl(data.featuredImage), asImageUrl(data.heroImage), asImageUrl(data.coverImage), asImageUrl(data.image), site?.defaultOgImage);
+    const ogImage = realImageUrl ??
+        (siteUrl && metaTitle
+            ? `${siteUrl}/api/cms/og.png?title=${encodeURIComponent(metaTitle)}`
+            : null);
+    const robots = resolveDocumentRobotsDirectives({
+        pageSettings: page,
+        data,
+        collectionSeo,
+        siteSeo: site,
+        environment: resolveSeoEnvironment(params.environment),
+    });
+    return { metaTitle, metaDescription, ogImage, noindex: robots.noIndex };
+}
+function pickString(...candidates) {
+    for (const c of candidates) {
+        if (typeof c === 'string' && c.trim().length > 0)
+            return c;
+    }
+    return undefined;
+}
+function siteTitleTemplateVars(params) {
+    const { data, page, collection, schemaType, publishedAt } = params;
+    return {
+        type: pickString(collection?.labels?.singular, schemaType),
+        author: pickString(data.authorName, data.author),
+        date: asIsoDate(publishedAt ?? data.publishedAt)?.slice(0, 10),
+        category: pickString(data.category, data.categories?.[0]),
+        tag: pickString(data.tags?.[0], data.tag),
+    };
+}
+/**
+ * Coerce a media-ish value to a URL string. Accepts a bare URL string or a
+ * media object (`{ url }` / `{ src }` / `{ publicUrl }`); rejects bare media
+ * IDs and other non-URL strings so JSON-LD never emits a cuid as `image`.
+ */
+function asImageUrl(value) {
+    if (typeof value === 'string') {
+        const v = value.trim();
+        if (!v)
+            return undefined;
+        if (v.startsWith('http://') || v.startsWith('https://'))
+            return v;
+        if (v.startsWith('/') && !v.startsWith('//'))
+            return v;
+        return undefined;
+    }
+    if (value && typeof value === 'object') {
+        const obj = value;
+        const url = obj.url ?? obj.src ?? obj.publicUrl;
+        if (typeof url === 'string')
+            return asImageUrl(url);
+    }
+    return undefined;
+}
+function asIsoDate(v) {
+    if (!v)
+        return undefined;
+    if (v instanceof Date)
+        return v.toISOString();
+    if (typeof v === 'string') {
+        const d = new Date(v);
+        return isNaN(d.getTime()) ? undefined : d.toISOString();
+    }
+    return undefined;
+}
+/**
+ * Resolve the canonical freshness dates for a document so every public surface
+ * (JSON-LD, Open Graph, etc.) reports the same recency. `datePublished` prefers
+ * the DB `publishedAt` (set on first publish) but falls back to editorial date
+ * fields authors set in the body (`publishedAt`/`publishedDate`/`publishDate`/
+ * `date`). `dateModified` prefers `updatedAt` and never predates publication.
+ */
+export function resolveContentDates(params) {
+    const data = params.data ?? {};
+    const page = params.page ?? {};
+    const datePublished = asIsoDate(params.doc.publishedAt ??
+        data.publishedAt ??
+        page.publishedAt ??
+        data.publishedDate ??
+        data.publishDate ??
+        data.date);
+    const dateModified = asIsoDate(params.doc.updatedAt ?? data.updatedAt ?? page.updatedAt) ?? datePublished;
+    return {
+        ...(datePublished ? { datePublished } : {}),
+        ...(dateModified ? { dateModified } : {}),
+    };
+}
+/** Schema.org types that the rich graph foundation already models as nodes. */
+const FOUNDATION_TYPES = new Set(['WebPage', 'Article', 'BlogPosting', 'NewsArticle', 'FAQPage']);
+/** Map a Schema.org type to the page-input content type the graph builder uses. */
+function schemaTypeToPageType(type) {
+    switch (type) {
+        case 'BlogPosting':
+            return 'blog';
+        case 'Article':
+        case 'NewsArticle':
+            return 'article';
+        case 'FAQPage':
+            return 'faq';
+        default:
+            return 'page';
+    }
+}
+/** Title-case a URL slug segment for a readable breadcrumb name. */
+function humanizeSegment(segment) {
+    const decoded = decodeURIComponent(segment).replace(/[-_]+/g, ' ').trim();
+    return decoded.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+/**
+ * Derive a BreadcrumbList trail from the page URL: Home → each path segment →
+ * the current page (named with its real title). Returns an empty array for the
+ * homepage so we never emit a single-item or self-referential breadcrumb.
+ */
+function deriveBreadcrumbs(siteUrl, url, title) {
+    const base = trimTrailingSlash(siteUrl);
+    if (!url || url === base || url === `${base}/`)
+        return [];
+    const path = base && url.startsWith(base) ? url.slice(base.length) : url;
+    const segments = path
+        .replace(/^\/+|\/+$/g, '')
+        .split('/')
+        .filter(Boolean);
+    if (segments.length === 0)
+        return [];
+    const crumbs = [{ name: 'Home', url: base || '/' }];
+    let acc = base;
+    segments.forEach((seg, i) => {
+        acc = `${acc}/${seg}`;
+        const isLast = i === segments.length - 1;
+        crumbs.push({ name: isLast ? title : humanizeSegment(seg), url: acc });
+    });
+    return crumbs;
+}
+/** Extract FAQ pairs from common document shapes (faqItems / faqs / questions). */
+function extractFaqItems(data, page) {
+    const raw = data.faqItems ?? data.faqs ?? data.questions ?? page.faqItems;
+    if (!Array.isArray(raw))
+        return [];
+    const items = [];
+    for (const entry of raw) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const e = entry;
+        const question = pickString(e.question, e.q, e.title);
+        const answer = pickString(e.answer, e.a, e.body, e.text);
+        if (question && answer)
+            items.push({ question, answer });
+    }
+    return items;
+}
+function asStringArray(...candidates) {
+    for (const c of candidates) {
+        if (Array.isArray(c)) {
+            const strings = c.filter((x) => typeof x === 'string' && x.trim().length > 0);
+            if (strings.length > 0)
+                return strings;
+        }
+        if (typeof c === 'string' && c.trim().length > 0)
+            return [c];
+    }
+    return undefined;
+}
+/**
+ * Build the additional entity node for Schema.org types the graph foundation
+ * doesn't model directly (LocalBusiness, Service, Product, Event, Person, …),
+ * linked to the page's WebPage node via `mainEntityOfPage`. Returns null for
+ * foundation types (already represented as WebPage/Article nodes).
+ */
+function buildSpecializedEntity(type, doc, meta, site) {
+    if (FOUNDATION_TYPES.has(type))
+        return null;
+    const data = (doc.data ?? {});
+    const page = (doc.pageSettings ?? {});
+    const siteUrl = trimTrailingSlash(site?.siteUrl ?? '');
+    const node = {
+        '@type': type,
+        '@id': `${meta.url}#entity`,
+        name: meta.title,
+        url: meta.url,
+        mainEntityOfPage: { '@id': meta.url },
+    };
+    if (meta.description)
+        node.description = meta.description;
+    if (meta.image)
+        node.image = { '@id': meta.image };
+    if (type === 'LocalBusiness' || type === 'Service') {
+        const address = data.address ?? page.address;
+        if (address && typeof address === 'object') {
+            node.address = { '@type': 'PostalAddress', ...address };
+        }
+        const phone = pickString(data.phone, data.telephone, page.phone);
+        if (phone)
+            node.telephone = phone;
+        const priceRange = pickString(data.priceRange, page.priceRange);
+        if (priceRange)
+            node.priceRange = priceRange;
+        if (siteUrl)
+            node.provider = { '@id': `${siteUrl}/#organization` };
+    }
+    if (type === 'Product') {
+        const brand = pickString(data.brand, page.brand);
+        if (brand)
+            node.brand = { '@type': 'Brand', name: brand };
+    }
+    // Strict types with hard required-field sets: emit ONLY when those fields are
+    // present, otherwise suppress the node entirely. A structurally-invalid
+    // Review/Event/JobPosting triggers Search Console "Missing field" errors and
+    // is ineligible for rich results, so a missing-field node is worse than none.
+    if (type === 'Review') {
+        const ratingValue = asRatingValue(data.reviewRating ?? data.rating ?? data.ratingValue);
+        const author = pickString(data.author, data.reviewAuthor, data.authorName, data.reviewer);
+        const itemReviewed = pickString(data.itemReviewed, data.subject, data.productName, data.itemName);
+        if (ratingValue == null || !author || !itemReviewed)
+            return null;
+        node.reviewRating = {
+            '@type': 'Rating',
+            ratingValue,
+            bestRating: asRatingValue(data.bestRating) ?? 5,
+        };
+        node.author = { '@type': 'Person', name: author };
+        node.itemReviewed = { '@type': 'Thing', name: itemReviewed };
+    }
+    if (type === 'Event') {
+        const startDate = asIsoDate(data.startDate ?? data.eventStart ?? data.startsAt ?? data.date);
+        if (!startDate)
+            return null;
+        node.startDate = startDate;
+        const endDate = asIsoDate(data.endDate ?? data.eventEnd ?? data.endsAt);
+        if (endDate)
+            node.endDate = endDate;
+        const location = pickString(data.location, data.venue, page.location, page.venue);
+        if (location)
+            node.location = { '@type': 'Place', name: location };
+    }
+    if (type === 'JobPosting') {
+        const datePosted = asIsoDate(doc.publishedAt ?? data.datePosted ?? data.publishedAt ?? data.date);
+        if (!datePosted)
+            return null;
+        const hiringOrganization = pickString(data.hiringOrganization, data.employer, data.company, site?.organization?.name, site?.siteName);
+        if (!hiringOrganization)
+            return null;
+        node.title = pickString(data.jobTitle, data.title) ?? meta.title;
+        node.datePosted = datePosted;
+        node.hiringOrganization = { '@type': 'Organization', name: hiringOrganization };
+        const validThrough = asIsoDate(data.validThrough ?? data.applicationDeadline);
+        if (validThrough)
+            node.validThrough = validThrough;
+    }
+    return node;
+}
+/** Coerce a rating-ish value (number or numeric string) to a number, else null. */
+function asRatingValue(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim() !== '') {
+        const n = Number(value);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return null;
+}
+/**
+ * Compose a connected Schema.org `@graph` for a document. Stacks the WebSite +
+ * Organization (+ sameAs / SearchAction) site nodes, the page node (WebPage or
+ * Article/BlogPosting), a derived BreadcrumbList, FAQ `mainEntity`, and an
+ * optional specialized entity node (LocalBusiness, Service, …) — so every page
+ * ships a single graph that search engines and AI crawlers can traverse,
+ * rather than an isolated flat object.
+ *
+ * Heuristic field mapping keeps default content working without per-collection
+ * wiring. A doc-level `structuredData` override is honored verbatim (the editor
+ * knows best).
+ */
+function composeJsonLd(type, doc, meta, site, config) {
+    const data = (doc.data ?? {});
+    const page = (doc.pageSettings ?? {});
+    // Doc-level override: if structuredData is already populated, use it (with
+    // Organization subtype normalization so Corporation/OnlineBusiness-only
+    // graphs still satisfy tooling that matches literal Organization).
+    if (doc.structuredData &&
+        typeof doc.structuredData === 'object' &&
+        Object.keys(doc.structuredData).length > 0) {
+        const sd = doc.structuredData;
+        return normalizeOrganizationTypesInJsonLd({
+            '@context': sd['@context'] ?? 'https://schema.org',
+            ...sd,
+        });
+    }
+    const siteUrl = trimTrailingSlash(site?.siteUrl ?? '');
+    const defaultLanguage = config?.i18n?.defaultLocale;
+    const siteSchema = {
+        siteName: site?.siteName ?? 'Site',
+        siteUrl,
+        siteDescription: site?.defaultMetaDescription,
+        organizationName: site?.organization?.name ?? site?.siteName,
+        organizationUrl: site?.organization?.url,
+        organizationLogo: site?.organization?.logo,
+        organizationSameAs: site?.organization?.sameAs,
+        // Sitelinks Searchbox (WebSite SearchAction) + Organization subtype — only
+        // emitted downstream when the operator actually configures them.
+        ...(site?.organization?.type ? { organizationType: site.organization.type } : {}),
+        ...(site?.searchUrlTemplate ? { searchUrlTemplate: site.searchUrlTemplate } : {}),
+        defaultLanguage,
+    };
+    const { datePublished, dateModified } = resolveContentDates({ doc, data, page });
+    const authorName = pickString(data.authorName, data.author, data.author?.name);
+    const faqItems = extractFaqItems(data, page);
+    // GEO key takeaway → Schema.org `abstract` (a citable summary for AI engines).
+    const keyTakeaway = pickString(page.keyTakeaway, data.keyTakeaway);
+    const pageInput = {
+        url: meta.url,
+        title: meta.title,
+        description: meta.description,
+        type: schemaTypeToPageType(type),
+        // Preserve the exact article @type (Article / NewsArticle / BlogPosting) so
+        // a NewsArticle isn't silently downgraded to Article (news rich results).
+        ...(type === 'Article' || type === 'NewsArticle' || type === 'BlogPosting'
+            ? { articleType: type }
+            : {}),
+        ...(datePublished ? { datePublished } : {}),
+        ...(dateModified ? { dateModified } : {}),
+        ...(authorName ? { author: { name: authorName } } : {}),
+        ...(meta.image ? { featuredImage: { url: meta.image } } : {}),
+        ...(faqItems.length > 0 ? { faqItems } : {}),
+        ...(keyTakeaway ? { abstract: keyTakeaway } : {}),
+        breadcrumbs: deriveBreadcrumbs(siteUrl, meta.url, meta.title),
+        keywords: asStringArray(data.keywords, data.tags),
+        articleSection: asStringArray(data.category, data.categories),
+        language: defaultLanguage,
+    };
+    const graphObj = buildSchemaGraph(siteSchema, pageInput);
+    const graph = [...graphObj['@graph']];
+    const entity = buildSpecializedEntity(type, doc, meta, site);
+    if (entity) {
+        const aggregateRating = extractAggregateRatingFromSections(data);
+        if (aggregateRating && (type === 'Service' || type === 'Product')) {
+            entity.aggregateRating = aggregateRating;
+        }
+        graph.push(entity);
+        // Cross-link the WebPage node to its primary entity for traversal.
+        const webPage = graph.find((n) => {
+            const t = n['@type'];
+            return t === 'WebPage' || (Array.isArray(t) && t.includes('WebPage'));
+        });
+        if (webPage)
+            webPage.mainEntity = { '@id': entity['@id'] };
+    }
+    return { '@context': 'https://schema.org', '@graph': graph };
+}
+/**
+ * Compose page meta + JSON-LD from a CMS document + collection config.
+ * Pure function — safe to call in any runtime (Edge, Node, browser).
+ */
+export function composePageMeta(input) {
+    const { doc, collection, config } = input;
+    const site = config?.seo;
+    const collectionSeo = collection?.seo;
+    const data = (doc.data ?? {});
+    const page = (doc.pageSettings ?? {});
+    const contentDates = resolveContentDates({ doc, data, page });
+    const siteUrl = input.siteUrl?.replace(/\/+$/, '') ?? site?.siteUrl?.replace(/\/+$/, '') ?? '';
+    const siteName = site?.siteName ?? 'Site';
+    const slug = (doc.slug ?? data.slug ?? '') || '';
+    const url = resolveDocumentUrl({
+        siteUrl,
+        urlPrefix: collection?.urlPrefix,
+        slug,
+        data,
+    });
+    // Pagination: the current page's own URL is the SELF-referencing canonical.
+    const pagination = input.pagination;
+    const pageNum = pagination && pagination.page > 0 ? pagination.page : 1;
+    const buildPageUrl = pagination?.urlForPage ?? ((n) => (n <= 1 ? url : `${url}?page=${n}`));
+    const selfUrl = pagination ? buildPageUrl(pageNum) : url;
+    const prevUrl = pagination && pageNum > 1 ? buildPageUrl(pageNum - 1) : undefined;
+    const nextUrl = pagination && pagination.pageCount != null && pageNum < pagination.pageCount
+        ? buildPageUrl(pageNum + 1)
+        : undefined;
+    const schemaType = pickString(page.schemaType, data.schemaType, data.structuredDataType, page.structuredDataType, collectionSeo?.defaultSchemaType) ??
+        input.defaultSchemaType ??
+        (collection?.slug ? detectSchemaType(collection.slug) : 'WebPage');
+    // Title: stored metaTitle is the page-specific portion (`%page%`). The site
+    // title template (Settings → SEO) is always applied at render time.
+    const metaTitlePage = pickString(page.metaTitle, data.metaTitle);
+    const rawTitle = pickString(data.title, page.title) ?? 'Untitled';
+    let title = resolveRenderedMetaTitle({
+        metaTitlePage,
+        documentTitle: rawTitle,
+        site,
+        vars: siteTitleTemplateVars({
+            data,
+            page,
+            collection,
+            schemaType,
+            publishedAt: doc.publishedAt ?? data.publishedAt,
+        }),
+    });
+    // Distinguish paginated pages 2..N in the public <title> / og:title.
+    if (pagination && pageNum > 1)
+        title = `${title} (Page ${pageNum})`;
+    // Description: per-document value wins, then the GEO key takeaway (a concise
+    // citable summary), then other summaries, then the site-wide default.
+    const description = pickString(page.metaDescription, data.metaDescription, page.keyTakeaway, data.keyTakeaway, data.excerpt, data.description, site?.defaultMetaDescription);
+    // Canonical: accept both the cms-core (`canonical`) and plugin-seo / SEO
+    // workspace (`canonicalUrl`) field names so a URL set in either surface is
+    // honored on the public page. An explicit override is absolutized +
+    // normalized against siteUrl (so a protocol-less `example.com/page` can't
+    // render as a path-relative canonical that disagrees with og:url); an
+    // unparseable value is rejected in favor of the resolved self URL.
+    const explicitCanonical = pickString(page.canonical, data.canonical, page.canonicalUrl, data.canonicalUrl);
+    let canonical = selfUrl;
+    if (explicitCanonical) {
+        const normalizedCanonical = normalizeCanonicalOverride(explicitCanonical, siteUrl);
+        if (normalizedCanonical) {
+            canonical = normalizedCanonical;
+        }
+        else if (typeof console !== 'undefined') {
+            console.warn(`[cms-core] Ignoring invalid canonical override ${JSON.stringify(explicitCanonical)} for ${url}`);
+        }
+    }
+    // Single source of truth for robots resolution (shared with the /seo/meta
+    // render path). Honors the `robotsPolicy` select field, explicit
+    // noindex/nofollow booleans, per-collection + site defaults, and the
+    // non-production indexing guard so staging deploys aren't indexed.
+    const robots = resolveDocumentRobotsDirectives({
+        pageSettings: page,
+        data,
+        collectionSeo,
+        siteSeo: site,
+        environment: resolveSeoEnvironment(input.environment),
+    });
+    if (input.forceNoIndex) {
+        robots.noIndex = true;
+    }
+    // A real, author-supplied image (used for the JSON-LD ImageObject — we don't
+    // want the dynamic OG generator URL polluting structured data). Falls back to
+    // the page's hero / featured / cover image (string or `{ url }`) before the
+    // site default, so social cards use the page's own visual when set.
+    const realImageUrl = pickString(page.ogImage, data.ogImage, asImageUrl(data.featuredImage), asImageUrl(data.heroImage), asImageUrl(data.coverImage), asImageUrl(data.image), site?.defaultOgImage) ?? undefined;
+    const ogImageUrl = realImageUrl ??
+        // The dynamic OG endpoint is served by the CMS API router, which is mounted
+        // under /api/cms — not the site root — so the default must include it or it
+        // 404s for social crawlers.
+        (siteUrl ? `${siteUrl}/api/cms/og.png?title=${encodeURIComponent(title)}` : undefined);
+    const ogType = schemaType === 'Article' || schemaType === 'BlogPosting' || schemaType === 'NewsArticle'
+        ? 'article'
+        : schemaType === 'Person'
+            ? 'profile'
+            : 'website';
+    const profileName = ogType === 'profile' ? resolvePersonNameParts(data, rawTitle) : undefined;
+    // The generated /og.png fallback is a known fixed 1200x630 card; declare its
+    // dimensions so social crawlers don't skip/slow-render it. All OG images get
+    // alt text (the page title) for card accessibility.
+    const usingGeneratedOg = !realImageUrl && !!ogImageUrl;
+    const metaInput = {
+        title,
+        description,
+        // og:url tracks the FINAL canonical (self URL, or an explicit override) so
+        // search + social consolidate on one URL for de-duplication.
+        url: canonical,
+        siteName,
+        canonical,
+        noIndex: robots.noIndex,
+        noFollow: robots.noFollow,
+        ogTitle: pickString(page.ogTitle, data.ogTitle),
+        ogDescription: pickString(page.ogDescription, data.ogDescription),
+        twitterTitle: pickString(page.twitterTitle, data.twitterTitle),
+        twitterDescription: pickString(page.twitterDescription, data.twitterDescription),
+        twitterImage: pickString(page.twitterImage, data.twitterImage),
+        twitterImageAlt: title,
+        type: ogType,
+        ...(profileName?.firstName ? { profileFirstName: profileName.firstName } : {}),
+        ...(profileName?.lastName ? { profileLastName: profileName.lastName } : {}),
+        ogImage: ogImageUrl
+            ? {
+                url: ogImageUrl,
+                alt: title,
+                ...(usingGeneratedOg ? { width: 1200, height: 630 } : {}),
+            }
+            : undefined,
+        twitterSite: site?.twitterHandle,
+        // Same resolved freshness dates the JSON-LD uses, so OG article times and
+        // structured data never disagree (and editorial dates are honored).
+        publishedTime: contentDates.datePublished,
+        modifiedTime: contentDates.dateModified,
+        author: pickString(data.authorName, data.author),
+        locale: config?.i18n?.defaultLocale,
+        localeAlternates: config?.i18n?.locales?.map((l) => l.code),
+        metadataBase: siteUrl || undefined,
+        alternates: input.alternates,
+        ...(prevUrl ? { prev: prevUrl } : {}),
+        ...(nextUrl ? { next: nextUrl } : {}),
+    };
+    const meta = generateMetaTags(metaInput);
+    let metaHtml = renderMetaTagsHtml(metaInput);
+    let metadata = generateNextMetadata(metaInput);
+    // Site-wide search-engine verification meta tags (Settings → SEO). These are
+    // injected into every public page's head; values are escaped and emitted only
+    // as safe `<meta>` tags.
+    const verificationEntries = buildVerificationMetaEntries(site?.verification);
+    if (verificationEntries.length > 0) {
+        for (const e of verificationEntries) {
+            const key = e.name ?? e.property;
+            if (key)
+                meta[key] = e.content;
+        }
+        const verificationHtml = renderVerificationMetaHtml(site?.verification);
+        if (verificationHtml)
+            metaHtml = `${metaHtml}\n${verificationHtml}`;
+        const nextVerification = buildNextVerification(site?.verification);
+        if (nextVerification)
+            metadata = { ...metadata, verification: nextVerification };
+    }
+    const jsonLd = composeJsonLd(schemaType, doc, { title, description, url, image: realImageUrl }, site, config);
+    const jsonLdHtml = jsonLd
+        ? `<script type="application/ld+json">${JSON.stringify(jsonLd).replace(/</g, '\\u003c')}</script>`
+        : '';
+    return {
+        url: selfUrl,
+        title,
+        description,
+        canonical,
+        jsonLd,
+        jsonLdHtml,
+        meta,
+        metaHtml,
+        metadata,
+    };
+}
+export { detectSchemaType };
+//# sourceMappingURL=page-meta.js.map