@sonordev/site-kit 6.5.0 → 7.0.0

package/dist/chunk-TXBAOEKG.js

@@ -0,0 +1,1084 @@
+import { generateArticleAuthorNode, resolveArticleArtwork, withArticleAuthorIdentity } from './chunk-QXMIKDOL.js';
+import { resolveArticleUrl, createPublicationRoutes, resolvePublicationUrl, articleCategorySlug } from './chunk-WMVK77ND.js';
+import { withSiteParam, withSiteBody } from './chunk-MJP63SSS.js';
+import { resolveServerApiConfig } from './chunk-X6F6SO4S.js';
+import { notFound } from 'next/navigation';
+
+// src/articles/public-reads.ts
+async function fetchArticleBySlug({ apiUrl, apiKey, site }, slug) {
+  try {
+    const response = await fetch(withSiteParam(`${apiUrl}/public/articles/posts/${slug}`, site), {
+      headers: { "x-api-key": apiKey },
+      next: { revalidate: 60 }
+    });
+    if (!response.ok) {
+      if (response.status !== 404) console.error("[Articles] Failed to fetch post:", response.statusText);
+      return null;
+    }
+    const data = await response.json();
+    return data.post || null;
+  } catch (error) {
+    console.error("[Articles] Error fetching post:", error);
+    return null;
+  }
+}
+async function fetchArticleCategories({ apiUrl, apiKey, site }) {
+  try {
+    const response = await fetch(withSiteParam(`${apiUrl}/public/articles/categories`, site), {
+      headers: { "x-api-key": apiKey },
+      next: { revalidate: 300 }
+    });
+    if (!response.ok) return [];
+    const data = await response.json();
+    return data.categories || [];
+  } catch (error) {
+    console.error("[Articles] Error fetching categories:", error);
+    return [];
+  }
+}
+async function fetchRelatedArticles({ apiUrl, apiKey, site }, currentPostId, limit, cache = {}) {
+  try {
+    const response = await fetch(`${apiUrl}/public/articles/related`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "x-api-key": apiKey },
+      body: JSON.stringify(withSiteBody({ current_post_id: currentPostId, limit }, site)),
+      ...cache.revalidate !== void 0 ? { next: { revalidate: cache.revalidate } } : {}
+    });
+    if (!response.ok) {
+      console.error("[Articles] Failed to fetch related posts:", response.statusText);
+      return [];
+    }
+    const data = await response.json();
+    return data.posts || [];
+  } catch (error) {
+    console.error("[Articles] Error fetching related posts:", error);
+    return [];
+  }
+}
+
+// src/articles/excerpt.ts
+function sanitizeExcerpt(raw, maxLength = 160) {
+  if (!raw) return "";
+  let text = String(raw).trim();
+  if (text.startsWith("{") || text.startsWith("[")) {
+    const fromSections = (value) => {
+      const list = Array.isArray(value) ? value : [value];
+      return list.map((s) => s && typeof s === "object" ? s.content || s.heading || "" : "").filter(Boolean).join(" ");
+    };
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      const first = text.split(/\}\s*[\r\n]+\s*\{/)[0];
+      try {
+        parsed = JSON.parse(first.endsWith("}") ? first : `${first}}`);
+      } catch {
+        parsed = null;
+      }
+    }
+    text = parsed ? fromSections(parsed) : text.replace(/[{}"[\]]/g, " ");
+  }
+  const plain = text.replace(/```[\s\S]*?```/g, " ").replace(/!\[[^\]]*\]\([^)]*\)/g, " ").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/^#{1,6}\s+/gm, "").replace(/[*_~`>]/g, "").replace(/\\n/g, " ").replace(/\s+/g, " ").trim();
+  if (plain.length <= maxLength) return plain;
+  const window = plain.slice(0, maxLength + 1);
+  const lastStop = Math.max(window.lastIndexOf(". "), window.lastIndexOf("? "), window.lastIndexOf("! "));
+  if (lastStop > maxLength * 0.5) return window.slice(0, lastStop + 1).trim();
+  const cut = plain.slice(0, maxLength);
+  const lastSpace = cut.lastIndexOf(" ");
+  return `${(lastSpace > maxLength * 0.6 ? cut.slice(0, lastSpace) : cut).replace(/[\s,;:—–-]+$/, "")}\u2026`;
+}
+
+// src/articles/news-sitemap.ts
+var NEWS_SITEMAP_WINDOW_MS = 2 * 24 * 60 * 60 * 1e3;
+var NEWS_SITEMAP_MAX_URLS = 1e3;
+var FEED_DEFAULT_ITEMS = 20;
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function cdata(html) {
+  return `<![CDATA[${html.replace(/]]>/g, "]]]]><![CDATA[>")}]]>`;
+}
+function recentNewsPosts(posts, now = /* @__PURE__ */ new Date()) {
+  const cutoff = now.getTime() - NEWS_SITEMAP_WINDOW_MS;
+  return posts.filter((post) => {
+    const published = post.published_at ? Date.parse(post.published_at) : NaN;
+    return Number.isFinite(published) && published >= cutoff && published <= now.getTime();
+  }).sort((a, b) => Date.parse(b.published_at) - Date.parse(a.published_at)).slice(0, NEWS_SITEMAP_MAX_URLS);
+}
+function buildNewsSitemapXml(posts, options, now = /* @__PURE__ */ new Date()) {
+  const language = options.language || "en";
+  const items = recentNewsPosts(posts, now).map((post) => {
+    const url = resolveArticleUrl(post, { ...options, siteUrl: options.siteUrl });
+    return `  <url>
+    <loc>${escapeXml(url)}</loc>
+    <news:news>
+      <news:publication>
+        <news:name>${escapeXml(options.publicationName)}</news:name>
+        <news:language>${escapeXml(language)}</news:language>
+      </news:publication>
+      <news:publication_date>${new Date(post.published_at).toISOString()}</news:publication_date>
+      <news:title>${escapeXml(post.title)}</news:title>
+    </news:news>
+  </url>`;
+  });
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:news="http://www.google.com/schemas/sitemap-news/0.9">
+${items.join("\n")}${items.length ? "\n" : ""}</urlset>`;
+}
+
+// src/articles/server-core.ts
+var SEO_LIMITS = {
+  title: { min: 30, max: 60, recommended: 55 },
+  metaDescription: { min: 120, max: 160, recommended: 155 },
+  excerpt: { min: 100, max: 300, recommended: 200 },
+  slug: { max: 75 },
+  focusKeyphrase: { min: 2, max: 4, words: true }
+  // 2-4 words
+};
+function validateSeoTitle(title, focusKeyphrase) {
+  const length = title.length;
+  let status = "good";
+  let message = "Title length is optimal";
+  if (length > SEO_LIMITS.title.max) {
+    status = "error";
+    message = `Title is ${length - SEO_LIMITS.title.max} characters too long (max ${SEO_LIMITS.title.max})`;
+  } else if (length < SEO_LIMITS.title.min) {
+    status = "warning";
+    message = `Title is short (${length}/${SEO_LIMITS.title.min} min)`;
+  } else if (focusKeyphrase && !title.toLowerCase().includes(focusKeyphrase.toLowerCase())) {
+    status = "warning";
+    message = "Focus keyphrase not found in title";
+  } else if (focusKeyphrase && !title.toLowerCase().startsWith(focusKeyphrase.toLowerCase())) {
+    status = "warning";
+    message = "Title should start with focus keyphrase for best results";
+  }
+  return { field: "title", value: title, length, limit: SEO_LIMITS.title, status, message };
+}
+function validateMetaDescription(description, focusKeyphrase) {
+  const length = description.length;
+  let status = "good";
+  let message = "Meta description is optimal";
+  if (length > SEO_LIMITS.metaDescription.max) {
+    status = "error";
+    message = `Description will be truncated (${length}/${SEO_LIMITS.metaDescription.max})`;
+  } else if (length < SEO_LIMITS.metaDescription.min) {
+    status = "warning";
+    message = `Description is short (${length}/${SEO_LIMITS.metaDescription.min} min)`;
+  } else if (focusKeyphrase && !description.toLowerCase().includes(focusKeyphrase.toLowerCase())) {
+    status = "warning";
+    message = "Focus keyphrase not found in description";
+  }
+  return { field: "meta_description", value: description, length, limit: SEO_LIMITS.metaDescription, status, message };
+}
+function validateArticleSeo(post) {
+  const results = [];
+  const focusKeyphrase = post.focus_keyphrase;
+  if (post.meta_title || post.title) {
+    results.push(validateSeoTitle(post.meta_title || post.title || "", focusKeyphrase));
+  }
+  if (post.meta_description) {
+    results.push(validateMetaDescription(post.meta_description, focusKeyphrase));
+  }
+  if (post.title && focusKeyphrase) {
+    const titleLower = post.title.toLowerCase();
+    const keyLower = focusKeyphrase.toLowerCase();
+    if (!titleLower.includes(keyLower)) {
+      results.push({
+        field: "h1_alignment",
+        value: post.title,
+        length: post.title.length,
+        limit: { max: 100 },
+        status: "warning",
+        message: "H1 (title) should include the focus keyphrase"
+      });
+    }
+  }
+  if (post.word_count !== void 0) {
+    let wordStatus = "good";
+    let wordMessage = "Content length is optimal for SEO";
+    if (post.word_count < 600) {
+      wordStatus = "error";
+      wordMessage = `Content is thin (${post.word_count} words). Aim for 1200+ words.`;
+    } else if (post.word_count < 1200) {
+      wordStatus = "warning";
+      wordMessage = `Content is short (${post.word_count} words). Long-form (1200-2500) ranks better.`;
+    } else if (post.word_count > 2500) {
+      wordMessage = `Comprehensive content (${post.word_count} words). Consider splitting into a topic cluster.`;
+    }
+    results.push({
+      field: "word_count",
+      value: String(post.word_count),
+      length: post.word_count,
+      limit: { min: 1200, max: 2500, recommended: 1800 },
+      status: wordStatus,
+      message: wordMessage
+    });
+  }
+  return results;
+}
+async function getArticle(slug, options) {
+  const config = resolveServerApiConfig();
+  if (!config) {
+    console.warn("[Articles] No API key configured");
+    return null;
+  }
+  return fetchArticleBySlug({ ...config, site: options?.site }, slug);
+}
+async function requireArticle(slug, options) {
+  const post = await getArticle(slug, options);
+  if (!post) notFound();
+  return post;
+}
+async function getAllArticleSlugs() {
+  const config = resolveServerApiConfig();
+  if (!config) {
+    console.warn("[Articles] No API key configured");
+    return [];
+  }
+  const { apiUrl, apiKey } = config;
+  try {
+    const response = await fetch(withSiteParam(`${apiUrl}/public/articles/slugs`), {
+      headers: { "x-api-key": apiKey },
+      next: { revalidate: 300 }
+    });
+    if (!response.ok) return [];
+    const data = await response.json();
+    return data.slugs || [];
+  } catch (error) {
+    console.error("[Articles] Error fetching slugs:", error);
+    return [];
+  }
+}
+async function getArticleCategories(options) {
+  const config = resolveServerApiConfig();
+  if (!config) return [];
+  return await fetchArticleCategories({ ...config, site: options?.site });
+}
+async function generateArticleMetadata(slug, options = {}) {
+  const post = await getArticle(slug);
+  const { siteName, siteUrl = "", defaultImage, twitterHandle } = options;
+  if (!post) {
+    if (options.notFound !== false) notFound();
+    return {
+      title: "Post Not Found",
+      description: "The requested article could not be found.",
+      robots: { index: false, follow: true }
+    };
+  }
+  const title = post.meta_title || post.title;
+  const description = sanitizeExcerpt(post.meta_description || post.excerpt);
+  const image = options.images === false ? void 0 : post.featured_image || defaultImage;
+  const url = resolveArticleUrl(post, options);
+  return {
+    title,
+    description,
+    openGraph: {
+      title: post.og_title || title,
+      description: post.og_description || description,
+      url,
+      siteName,
+      type: "article",
+      publishedTime: post.published_at,
+      authors: post.author ? [typeof post.author === "string" ? post.author : post.author.name] : void 0,
+      ...image && {
+        images: [
+          {
+            url: image,
+            width: 1200,
+            height: 630,
+            alt: post.featured_image_alt || post.title
+          }
+        ]
+      }
+    },
+    twitter: {
+      card: "summary_large_image",
+      title,
+      description,
+      ...image && { images: [image] },
+      creator: twitterHandle
+    },
+    alternates: {
+      canonical: url
+    },
+    other: {
+      "article:published_time": post.published_at || "",
+      "article:section": typeof post.category === "string" ? post.category : post.category?.name || ""
+    }
+  };
+}
+function generatePublicationMetadata(options) {
+  const {
+    title = "Blog",
+    description = "Read our latest articles and insights.",
+    siteName,
+    siteUrl = "",
+    defaultImage,
+    twitterHandle
+  } = options;
+  const base = createPublicationRoutes(options).index;
+  return {
+    title,
+    description,
+    openGraph: {
+      title,
+      description,
+      url: resolvePublicationUrl(base, siteUrl),
+      siteName,
+      type: "website",
+      ...defaultImage && { images: [{ url: defaultImage }] }
+    },
+    twitter: {
+      card: "summary_large_image",
+      title,
+      description,
+      ...defaultImage && { images: [defaultImage] },
+      creator: twitterHandle
+    }
+  };
+}
+function generateArticleCategoryMetadata(categoryName, options = {}) {
+  const { siteName, siteUrl = "", defaultImage } = options;
+  const title = `${categoryName} - Articles`;
+  const description = `Browse all posts in ${categoryName}.`;
+  const slug = options.categorySlug ?? categoryName.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return {
+    title,
+    description,
+    openGraph: {
+      title,
+      description,
+      url: resolvePublicationUrl(createPublicationRoutes(options).category(slug), siteUrl),
+      siteName,
+      type: "website",
+      ...defaultImage && { images: [{ url: defaultImage }] }
+    }
+  };
+}
+function isNextStaticParamsProps(value) {
+  return "params" in value;
+}
+async function generateArticleStaticParams(arg = {}) {
+  const options = isNextStaticParamsProps(arg) ? {} : arg;
+  const posts = await getArticleRouteEntries(options);
+  return posts.map((post) => {
+    const category = articleCategorySlug(post.category || options.category);
+    return { slug: post.slug, ...options.includeCategoryInPath && category ? { category } : {} };
+  });
+}
+async function generateCategoryStaticParams() {
+  const categories = await getArticleCategories();
+  return categories.map((c) => ({ category: c.slug }));
+}
+function absoluteImage(image, siteUrl) {
+  const value = image?.trim();
+  if (!value) return null;
+  try {
+    return new URL(value, siteUrl.endsWith("/") ? siteUrl : `${siteUrl}/`).toString();
+  } catch {
+    return null;
+  }
+}
+async function getArticleRouteEntries(options, withCanonicals = false) {
+  if (withCanonicals || options.includeCategoryInPath || options.postPath) {
+    return (await getAllArticles({ maxPosts: Infinity })).map((post) => ({ ...post, last_modified: post.updated_at }));
+  }
+  return getAllArticleSlugs();
+}
+async function generateArticleSitemap(siteUrl, options = {}) {
+  const slugs = await getArticleRouteEntries(options, true);
+  const categories = options.includeCategories === false ? [] : await getArticleCategories();
+  const clusters = options.includeClusters === false ? [] : await getTopicClusters();
+  const entries = [
+    // Publication index
+    {
+      url: resolvePublicationUrl(createPublicationRoutes(options).index, siteUrl),
+      changeFrequency: "daily",
+      priority: 0.8
+    }
+  ];
+  clusters.forEach((cluster) => {
+    entries.push({
+      url: resolvePublicationUrl(createPublicationRoutes(options).cluster(cluster.cluster_slug), siteUrl),
+      changeFrequency: "weekly",
+      priority: 0.8
+    });
+  });
+  categories.forEach((cat) => {
+    entries.push({
+      url: resolvePublicationUrl(createPublicationRoutes(options).category(cat.slug), siteUrl),
+      changeFrequency: "weekly",
+      priority: 0.6
+    });
+  });
+  slugs.forEach((post) => {
+    const isPillar = post.article_type === "pillar";
+    const image = absoluteImage(post.featured_image, siteUrl);
+    entries.push({
+      url: resolveArticleUrl(post, { ...options, siteUrl }),
+      lastModified: post.last_modified ? new Date(post.last_modified) : void 0,
+      changeFrequency: isPillar ? "weekly" : "monthly",
+      priority: isPillar ? 0.9 : 0.7,
+      ...image ? { images: [image] } : {}
+    });
+  });
+  return entries;
+}
+async function generateNewsSitemap(options) {
+  const posts = await getAllArticles({ maxPosts: 50, site: options.site });
+  return buildNewsSitemapXml(posts, options);
+}
+function generateArticleSchema(post, options = {}) {
+  const { siteUrl = "", siteName, logoUrl } = options;
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "BlogPosting",
+    headline: post.title,
+    description: sanitizeExcerpt(post.excerpt || post.meta_description),
+    url: resolveArticleUrl(post, { ...options, siteUrl }),
+    datePublished: post.published_at,
+    dateModified: post.updated_at
+  };
+  const author = generateArticleAuthorNode(post.author, options);
+  if (author) schema.author = author;
+  const articleImage = resolveArticleArtwork(post, "article").src;
+  if (articleImage) schema.image = articleImage;
+  if (siteName || logoUrl) {
+    schema.publisher = {
+      "@type": "Organization",
+      name: siteName,
+      logo: logoUrl ? {
+        "@type": "ImageObject",
+        url: logoUrl
+      } : void 0
+    };
+  }
+  if (post.faq_items && Array.isArray(post.faq_items) && post.faq_items.length > 0) {
+    schema.mainEntity = {
+      "@type": "FAQPage",
+      mainEntity: post.faq_items.map((faq) => ({
+        "@type": "Question",
+        name: faq.question,
+        acceptedAnswer: {
+          "@type": "Answer",
+          text: faq.answer
+        }
+      }))
+    };
+  }
+  return schema;
+}
+function generateArticleListSchema(options = {}) {
+  const { siteUrl = "", siteName, description } = options;
+  return {
+    "@context": "https://schema.org",
+    "@type": "Blog",
+    name: siteName ? `${siteName} Blog` : "Blog",
+    description: description || "Our latest articles and insights.",
+    url: resolvePublicationUrl(createPublicationRoutes(options).index, siteUrl)
+  };
+}
+function generateFaqSchema(faqItems) {
+  if (!faqItems || faqItems.length === 0) return null;
+  return {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    mainEntity: faqItems.map((faq) => ({
+      "@type": "Question",
+      name: faq.question,
+      acceptedAnswer: {
+        "@type": "Answer",
+        text: faq.answer
+      }
+    }))
+  };
+}
+function generateHowToSchema(post, steps, options = {}) {
+  const { siteUrl = "" } = options;
+  return {
+    "@context": "https://schema.org",
+    "@type": "HowTo",
+    name: post.title,
+    description: sanitizeExcerpt(post.excerpt || post.meta_description),
+    image: resolveArticleArtwork(post, "article").src,
+    totalTime: post.reading_time ? `PT${post.reading_time}M` : void 0,
+    step: steps.map((step, index) => ({
+      "@type": "HowToStep",
+      position: index + 1,
+      name: step.name,
+      text: step.text,
+      image: step.image,
+      url: step.url || `${resolveArticleUrl(post, { ...options, siteUrl }).split("#")[0]}#step-${index + 1}`
+    }))
+  };
+}
+var FEED_MAX_POSTS = 100;
+async function getAllArticles(options = {}) {
+  const maxPosts = options.maxPosts ?? FEED_MAX_POSTS;
+  if (!(maxPosts > 0)) return [];
+  const config = resolveServerApiConfig();
+  if (!config) {
+    console.warn("[Articles] No API key configured");
+    return [];
+  }
+  const { apiUrl, apiKey } = config;
+  const posts = [];
+  let page = 1;
+  try {
+    while (posts.length < maxPosts) {
+      const response = await fetch(
+        withSiteParam(`${apiUrl}/public/articles/posts?per_page=50&page=${page}`, options.site),
+        {
+          headers: { "x-api-key": apiKey },
+          next: { revalidate: 300 }
+        }
+      );
+      if (!response.ok) break;
+      const data = await response.json();
+      const batch = data.posts || [];
+      posts.push(...batch);
+      if (!batch.length || !data.pagination?.has_next) break;
+      page += 1;
+    }
+  } catch (error) {
+    console.error("[Articles] Error fetching posts for RSS:", error);
+  }
+  return posts.slice(0, maxPosts);
+}
+function stripHtml(html) {
+  return html.replace(/<[^>]*>/g, "").trim();
+}
+async function generateRssFeed(options) {
+  const {
+    siteUrl,
+    siteName,
+    description = "Latest articles and insights",
+    language = "en-us",
+    copyright,
+    managingEditor,
+    webMaster,
+    ttl = 60,
+    imageUrl
+  } = options;
+  const posts = await getAllArticles({ maxPosts: options.maxItems ?? FEED_DEFAULT_ITEMS });
+  const now = (/* @__PURE__ */ new Date()).toUTCString();
+  let rss = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
+  <channel>
+    <title>${escapeXml(siteName)}</title>
+    <link>${siteUrl}</link>
+    <description>${escapeXml(description)}</description>
+    <language>${language}</language>
+    <lastBuildDate>${now}</lastBuildDate>
+    <pubDate>${now}</pubDate>
+    <ttl>${ttl}</ttl>
+    <atom:link href="${escapeXml(resolvePublicationUrl(createPublicationRoutes(options).rss, siteUrl))}" rel="self" type="application/rss+xml"/>
+`;
+  if (copyright) {
+    rss += `    <copyright>${escapeXml(copyright)}</copyright>
+`;
+  }
+  if (managingEditor) {
+    rss += `    <managingEditor>${escapeXml(managingEditor)}</managingEditor>
+`;
+  }
+  if (webMaster) {
+    rss += `    <webMaster>${escapeXml(webMaster)}</webMaster>
+`;
+  }
+  if (imageUrl) {
+    rss += `    <image>
+      <url>${imageUrl}</url>
+      <title>${escapeXml(siteName)}</title>
+      <link>${siteUrl}</link>
+    </image>
+`;
+  }
+  for (const post of posts) {
+    const postUrl = resolveArticleUrl(post, { ...options, siteUrl });
+    const pubDate = post.published_at ? new Date(post.published_at).toUTCString() : now;
+    const author = typeof post.author === "string" ? post.author : post.author?.name || "Unknown";
+    const fullContent = post.content_html || post.content || "";
+    const description2 = sanitizeExcerpt(post.excerpt, 300) || stripHtml(fullContent).substring(0, 300) + "...";
+    rss += `    <item>
+      <title>${escapeXml(post.title)}</title>
+      <link>${escapeXml(postUrl)}</link>
+      <guid isPermaLink="true">${escapeXml(postUrl)}</guid>
+      <description>${escapeXml(description2)}</description>
+      <content:encoded>${cdata(fullContent)}</content:encoded>
+      <pubDate>${pubDate}</pubDate>
+      <author>${escapeXml(author)}</author>
+`;
+    if (post.category) {
+      const categoryName = typeof post.category === "string" ? post.category : post.category.name;
+      rss += `      <category>${escapeXml(categoryName)}</category>
+`;
+    }
+    if (post.tags && Array.isArray(post.tags)) {
+      for (const tag of post.tags) {
+        const tagName = typeof tag === "string" ? tag : tag.name;
+        rss += `      <category>${escapeXml(tagName)}</category>
+`;
+      }
+    }
+    if (post.featured_image) {
+      rss += `      <enclosure url="${post.featured_image}" type="image/jpeg"/>
+`;
+    }
+    rss += `    </item>
+`;
+  }
+  rss += `  </channel>
+</rss>`;
+  return rss;
+}
+async function generateAtomFeed(options) {
+  const {
+    siteUrl,
+    siteName,
+    description = "Latest articles and insights",
+    managingEditor
+  } = options;
+  const posts = await getAllArticles({ maxPosts: options.maxItems ?? FEED_DEFAULT_ITEMS });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let atom = `<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title>${escapeXml(siteName)}</title>
+  <subtitle>${escapeXml(description)}</subtitle>
+  <link href="${escapeXml(resolvePublicationUrl(createPublicationRoutes(options).atom, siteUrl))}" rel="self"/>
+  <link href="${siteUrl}"/>
+  <id>${escapeXml(resolvePublicationUrl(createPublicationRoutes(options).index, siteUrl))}</id>
+  <updated>${now}</updated>
+`;
+  if (managingEditor) {
+    atom += `  <author>
+    <name>${escapeXml(managingEditor)}</name>
+  </author>
+`;
+  }
+  for (const post of posts) {
+    const postUrl = resolveArticleUrl(post, { ...options, siteUrl });
+    const updated = post.updated_at || post.published_at || now;
+    const published = post.published_at || now;
+    const author = typeof post.author === "string" ? post.author : post.author?.name || "Unknown";
+    const fullContent = post.content_html || post.content || "";
+    atom += `  <entry>
+    <title>${escapeXml(post.title)}</title>
+    <link href="${escapeXml(postUrl)}"/>
+    <id>${escapeXml(postUrl)}</id>
+    <updated>${new Date(updated).toISOString()}</updated>
+    <published>${new Date(published).toISOString()}</published>
+    <author>
+      <name>${escapeXml(author)}</name>
+    </author>
+    <summary>${escapeXml(sanitizeExcerpt(post.excerpt, 300) || stripHtml(fullContent).substring(0, 300))}</summary>
+    <content type="html">${cdata(fullContent)}</content>
+  </entry>
+`;
+  }
+  atom += `</feed>`;
+  return atom;
+}
+async function getTopicClusters(options) {
+  const config = resolveServerApiConfig();
+  if (!config) return [];
+  const { apiUrl, apiKey } = config;
+  try {
+    const response = await fetch(withSiteParam(`${apiUrl}/public/articles/clusters`, options?.site), {
+      headers: { "x-api-key": apiKey },
+      next: { revalidate: 300 }
+    });
+    if (!response.ok) return [];
+    const data = await response.json();
+    return (data.clusters || []).map((c) => ({
+      id: c.id,
+      cluster_name: c.cluster_name,
+      cluster_slug: c.cluster_slug,
+      core_topic: c.core_topic,
+      primary_entity: c.primary_entity,
+      industry: c.industry,
+      geo_target: c.geo_target,
+      commercial_goal: c.commercial_goal,
+      pillar_post_id: c.pillar_post_id,
+      target_service_page: c.target_service_page,
+      article_count: c.article_count,
+      created_at: c.created_at,
+      pillar: null,
+      supports: [],
+      interlink_map: []
+    }));
+  } catch (error) {
+    console.error("[Articles] Error fetching topic clusters:", error);
+    return [];
+  }
+}
+async function getTopicCluster(slug, options) {
+  const config = resolveServerApiConfig();
+  if (!config) return null;
+  const { apiUrl, apiKey } = config;
+  try {
+    const response = await fetch(withSiteParam(`${apiUrl}/public/articles/clusters/${slug}`, options?.site), {
+      headers: { "x-api-key": apiKey },
+      next: { revalidate: 300 }
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    return {
+      id: data.id,
+      cluster_name: data.cluster_name,
+      cluster_slug: data.cluster_slug,
+      core_topic: data.core_topic,
+      primary_entity: data.primary_entity,
+      industry: data.industry,
+      geo_target: data.geo_target,
+      commercial_goal: data.commercial_goal,
+      // Authoritative column once the API's detail response ships it;
+      // derived from the embedded (published) pillar until then.
+      pillar_post_id: data.pillar_post_id ?? data.pillar?.id,
+      target_service_page: data.target_service_page,
+      article_count: data.article_count,
+      created_at: data.created_at,
+      pillar: data.pillar || null,
+      supports: data.supports || [],
+      interlink_map: data.interlink_map || []
+    };
+  } catch (error) {
+    console.error("[Articles] Error fetching topic cluster:", error);
+    return null;
+  }
+}
+function getClusterNavigation(post) {
+  if (!post.cluster_id && !post.cluster_slug) return null;
+  const isPillar = post.article_type === "pillar";
+  return {
+    cluster_name: post.cluster_name || "",
+    cluster_slug: post.cluster_slug || "",
+    pillar: isPillar ? null : post.parent_pillar_slug ? {
+      slug: post.parent_pillar_slug,
+      title: post.parent_pillar_title || "",
+      category: post.parent_pillar_category || void 0
+    } : null,
+    siblings: post.sibling_articles || [],
+    is_pillar: isPillar
+  };
+}
+async function getPostsByCategory(categorySlug, options) {
+  const config = resolveServerApiConfig();
+  if (!config) return [];
+  const { apiUrl, apiKey } = config;
+  try {
+    const response = await fetch(withSiteParam(`${apiUrl}/public/articles/posts?category=${encodeURIComponent(categorySlug)}&per_page=50`, options?.site), {
+      headers: { "x-api-key": apiKey },
+      next: { revalidate: 300 }
+    });
+    if (!response.ok) return [];
+    const data = await response.json();
+    return data.posts || [];
+  } catch (error) {
+    console.error("[Articles] Error fetching category posts:", error);
+    return [];
+  }
+}
+function generateClusterItemListSchema(cluster, options = {}) {
+  const { siteUrl = "" } = options;
+  return {
+    "@context": "https://schema.org",
+    "@type": "ItemList",
+    name: cluster.cluster_name,
+    description: `Articles about ${cluster.core_topic}`,
+    numberOfItems: cluster.supports.length,
+    itemListElement: cluster.supports.map((post, i) => ({
+      "@type": "ListItem",
+      position: i + 1,
+      name: post.title,
+      url: resolveArticleUrl(post, { ...options, siteUrl })
+    }))
+  };
+}
+function generateClusterArticleSchema(post, cluster, options = {}) {
+  const { siteUrl = "", siteName, logoUrl } = options;
+  const isPillar = post.article_type === "pillar";
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    headline: post.title,
+    description: sanitizeExcerpt(post.excerpt || post.meta_description),
+    url: resolveArticleUrl(post, { ...options, siteUrl }),
+    datePublished: post.published_at,
+    dateModified: post.updated_at,
+    keywords: post.focus_keyphrase || post.keywords
+  };
+  const author = generateArticleAuthorNode(post.author, options);
+  if (author) schema.author = author;
+  const articleImage = resolveArticleArtwork(post, "article").src;
+  if (articleImage) schema.image = articleImage;
+  if (siteName || logoUrl) {
+    schema.publisher = {
+      "@type": "Organization",
+      name: siteName,
+      ...logoUrl && { logo: { "@type": "ImageObject", url: logoUrl } }
+    };
+  }
+  if (isPillar && cluster.supports.length > 0) {
+    schema.hasPart = cluster.supports.map((s) => ({
+      "@type": "Article",
+      headline: s.title,
+      url: resolveArticleUrl(s, { ...options, siteUrl })
+    }));
+  } else if (!isPillar && cluster.pillar) {
+    schema.isPartOf = {
+      "@type": "Article",
+      headline: cluster.pillar.title,
+      url: resolveArticleUrl(cluster.pillar, { ...options, siteUrl })
+    };
+  }
+  if (cluster.geo_target) {
+    schema.spatialCoverage = {
+      "@type": "Place",
+      name: cluster.geo_target
+    };
+  }
+  return schema;
+}
+function generateClusterBreadcrumbSchema(post, cluster, options = {}) {
+  const { siteUrl = "", siteName = "Home" } = options;
+  const items = [
+    { "@type": "ListItem", position: 1, name: siteName, item: siteUrl },
+    { "@type": "ListItem", position: 2, name: "Blog", item: resolvePublicationUrl(createPublicationRoutes(options).index, siteUrl) },
+    {
+      "@type": "ListItem",
+      position: 3,
+      name: cluster.cluster_name,
+      item: resolvePublicationUrl(createPublicationRoutes(options).cluster(cluster.cluster_slug), siteUrl)
+    },
+    {
+      "@type": "ListItem",
+      position: 4,
+      name: post.title,
+      item: resolveArticleUrl(post, { ...options, siteUrl })
+    }
+  ];
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: items
+  };
+}
+function generateClusterLandingSchema(cluster, options = {}) {
+  const { siteUrl = "", siteName } = options;
+  return {
+    "@context": "https://schema.org",
+    "@type": "CollectionPage",
+    name: cluster.cluster_name,
+    description: `Comprehensive guide to ${cluster.core_topic}`,
+    url: resolvePublicationUrl(createPublicationRoutes(options).cluster(cluster.cluster_slug), siteUrl),
+    ...siteName && {
+      isPartOf: { "@type": "WebSite", name: siteName, url: siteUrl }
+    },
+    mainEntity: cluster.pillar ? {
+      "@type": "Article",
+      headline: cluster.pillar.title,
+      url: resolveArticleUrl(cluster.pillar, { ...options, siteUrl })
+    } : void 0,
+    hasPart: cluster.supports.map((s) => ({
+      "@type": "Article",
+      headline: s.title,
+      url: resolveArticleUrl(s, { ...options, siteUrl })
+    }))
+  };
+}
+async function generateClusterPageMetadata(clusterSlug, options = {}) {
+  const cluster = await getTopicCluster(clusterSlug);
+  if (!cluster) return {};
+  const { siteName = "", siteUrl = "" } = options;
+  const title = `${cluster.cluster_name}${siteName ? ` | ${siteName}` : ""}`;
+  const description = `Comprehensive guide to ${cluster.core_topic}. ${cluster.article_count} articles covering everything you need to know.`;
+  return {
+    title,
+    description,
+    openGraph: {
+      title,
+      description,
+      url: resolvePublicationUrl(createPublicationRoutes(options).cluster(cluster.cluster_slug), siteUrl),
+      type: "website"
+    }
+  };
+}
+async function getRelatedInsights(currentSlug, options = {}) {
+  const config = resolveServerApiConfig();
+  if (!config) return [];
+  const { limit = 3, site } = options;
+  const current = await getArticle(currentSlug, { site });
+  if (!current?.id) return [];
+  return fetchRelatedArticles({ ...config, site }, current.id, limit, { revalidate: 300 });
+}
+function generateBreadcrumbSchema(post, options = {}) {
+  const { siteUrl = "", siteName = "Home" } = options;
+  const items = [
+    {
+      "@type": "ListItem",
+      position: 1,
+      name: siteName,
+      item: siteUrl
+    },
+    {
+      "@type": "ListItem",
+      position: 2,
+      name: "Blog",
+      item: resolvePublicationUrl(createPublicationRoutes(options).index, siteUrl)
+    }
+  ];
+  if (post.category) {
+    const categoryName = typeof post.category === "string" ? post.category : post.category.name;
+    const categorySlug = typeof post.category === "string" ? post.category.toLowerCase().replace(/\s+/g, "-") : post.category.slug;
+    items.push({
+      "@type": "ListItem",
+      position: 3,
+      name: categoryName,
+      item: resolvePublicationUrl(createPublicationRoutes(options).category(categorySlug), siteUrl)
+    });
+    items.push({
+      "@type": "ListItem",
+      position: 4,
+      name: post.title,
+      item: resolveArticleUrl(post, { ...options, siteUrl })
+    });
+  } else {
+    items.push({
+      "@type": "ListItem",
+      position: 3,
+      name: post.title,
+      item: resolveArticleUrl(post, { ...options, siteUrl })
+    });
+  }
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: items
+  };
+}
+function generateAllArticleSchemas(post, options = {}) {
+  const schemas = [];
+  const eeatSchema = post.schema ?? post.schema_json;
+  if (eeatSchema) {
+    const arr = Array.isArray(eeatSchema) ? eeatSchema : [eeatSchema];
+    schemas.push(...arr.map((node) => withArticleAuthorIdentity(node, post.author, options)));
+  } else {
+    schemas.push(generateArticleSchema(post, options));
+    const faqItems = post.faq_items ?? post.faqItems;
+    if (faqItems && faqItems.length > 0) {
+      const faqSchema = generateFaqSchema(faqItems);
+      if (faqSchema) schemas.push(faqSchema);
+    }
+  }
+  schemas.push(generateBreadcrumbSchema(post, options));
+  return schemas;
+}
+async function getAuthorBySlug(slug, options) {
+  const config = resolveServerApiConfig();
+  if (!config) {
+    console.warn("[Articles] No API key configured");
+    return null;
+  }
+  const { apiUrl, apiKey } = config;
+  try {
+    const response = await fetch(withSiteParam(`${apiUrl}/public/articles/authors/${slug}`, options?.site), {
+      headers: { "x-api-key": apiKey },
+      next: { revalidate: 60 }
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    return data.author || null;
+  } catch (error) {
+    console.error("[Articles] Error fetching author:", error);
+    return null;
+  }
+}
+async function getAuthorPosts(slug, limit = 20, offset = 0, options) {
+  const config = resolveServerApiConfig();
+  if (!config) {
+    console.warn("[Articles] No API key configured");
+    return { author: null, posts: [], total: 0 };
+  }
+  const { apiUrl, apiKey } = config;
+  try {
+    const response = await fetch(
+      withSiteParam(`${apiUrl}/public/articles/authors/${slug}/posts?limit=${limit}&offset=${offset}`, options?.site),
+      {
+        headers: { "x-api-key": apiKey },
+        next: { revalidate: 60 }
+      }
+    );
+    if (!response.ok) return { author: null, posts: [], total: 0 };
+    const data = await response.json();
+    let author = data.author || null;
+    if (author && author.id === void 0) {
+      try {
+        const full = await getAuthorBySlug(slug, options);
+        if (full) author = full;
+      } catch {
+      }
+    }
+    return {
+      author,
+      posts: data.posts || [],
+      total: data.total || 0
+    };
+  } catch (error) {
+    console.error("[Articles] Error fetching author posts:", error);
+    return { author: null, posts: [], total: 0 };
+  }
+}
+async function getAllAuthorSlugs() {
+  const config = resolveServerApiConfig();
+  if (!config) {
+    console.warn("[Articles] No API key configured");
+    return [];
+  }
+  const { apiUrl, apiKey } = config;
+  try {
+    const response = await fetch(withSiteParam(`${apiUrl}/public/articles/authors`), {
+      headers: { "x-api-key": apiKey },
+      next: { revalidate: 300 }
+    });
+    if (!response.ok) return [];
+    const data = await response.json();
+    const authors = data.authors || [];
+    return authors.map((a) => ({ slug: a.slug }));
+  } catch (error) {
+    console.error("[Articles] Error fetching author slugs:", error);
+    return [];
+  }
+}
+async function generateAuthorStaticParams() {
+  return getAllAuthorSlugs();
+}
+function generateAuthorPageMetadata(author, options = {}) {
+  const { siteUrl = "", siteName } = options;
+  const title = `${author.name}${author.title ? ` - ${author.title}` : ""}`;
+  const description = author.short_bio || author.bio || `Articles by ${author.name}`;
+  const url = resolvePublicationUrl(createPublicationRoutes(options).author(author.slug), siteUrl);
+  return {
+    title,
+    description,
+    openGraph: {
+      title,
+      description,
+      url,
+      siteName,
+      type: "profile",
+      ...author.avatar_url && { images: [{ url: author.avatar_url }] }
+    },
+    twitter: {
+      card: "summary",
+      title,
+      description,
+      ...author.avatar_url && { images: [author.avatar_url] }
+    },
+    alternates: {
+      canonical: author.author_page_url || url
+    }
+  };
+}
+
+export { FEED_DEFAULT_ITEMS, NEWS_SITEMAP_MAX_URLS, NEWS_SITEMAP_WINDOW_MS, SEO_LIMITS, buildNewsSitemapXml, cdata, fetchArticleBySlug, fetchArticleCategories, fetchRelatedArticles, generateAllArticleSchemas, generateArticleCategoryMetadata, generateArticleListSchema, generateArticleMetadata, generateArticleSchema, generateArticleSitemap, generateArticleStaticParams, generateAtomFeed, generateAuthorPageMetadata, generateAuthorStaticParams, generateBreadcrumbSchema, generateCategoryStaticParams, generateClusterArticleSchema, generateClusterBreadcrumbSchema, generateClusterItemListSchema, generateClusterLandingSchema, generateClusterPageMetadata, generateFaqSchema, generateHowToSchema, generateNewsSitemap, generatePublicationMetadata, generateRssFeed, getAllArticleSlugs, getAllArticles, getAllAuthorSlugs, getArticle, getArticleCategories, getAuthorBySlug, getAuthorPosts, getClusterNavigation, getPostsByCategory, getRelatedInsights, getTopicCluster, getTopicClusters, recentNewsPosts, requireArticle, sanitizeExcerpt, validateArticleSeo, validateMetaDescription, validateSeoTitle };