@fullstackdatasolutions/articles 0.12.0 → 1.1.0

package/dist/server.cjs

@@ -84,17 +84,27 @@ __export(server_exports, {
   buildArticleBreadcrumbs: () => buildArticleBreadcrumbs,
   buildAuthorBreadcrumbs: () => buildAuthorBreadcrumbs,
   buildCategoryBreadcrumbs: () => buildCategoryBreadcrumbs,
+  buildPageUrl: () => buildPageUrl,
+  buildPaginationLinks: () => buildPaginationLinks,
   categoryToSlug: () => categoryToSlug,
+  emitArticleEvent: () => emitArticleEvent,
   extractToc: () => extractToc,
   generateArticleMetadata: () => generateArticleMetadata,
   generateArticleStaticParams: () => generateArticleStaticParams,
   generateArticlesIndexMetadata: () => generateArticlesIndexMetadata,
+  generateArticlesIndexPageMetadata: () => generateArticlesIndexPageMetadata,
   generateAuthorMetadata: () => generateAuthorMetadata,
+  generateAuthorPageMetadata: () => generateAuthorPageMetadata,
   generateAuthorStaticParams: () => generateAuthorStaticParams,
   generateCategoryMetadata: () => generateCategoryMetadata,
+  generateCategoryPageMetadata: () => generateCategoryPageMetadata,
   generateCategoryStaticParams: () => generateCategoryStaticParams,
+  generateListingPageStaticParams: () => generateListingPageStaticParams,
   generateRssFeed: () => generateRssFeed,
+  generateSeriesMetadata: () => generateSeriesMetadata,
+  generateSeriesStaticParams: () => generateSeriesStaticParams,
   getAdjacentArticles: () => getAdjacentArticles,
+  getAdjacentArticlesInSeries: () => getAdjacentArticlesInSeries,
   getAiRobotsTxtRules: () => getAiRobotsTxtRules,
   getAllArticles: () => getAllArticles,
   getAllAuthors: () => getAllAuthors,
@@ -108,14 +118,28 @@ __export(server_exports, {
   getArticleSitemapEntries: () => getArticleSitemapEntries,
   getArticlesByAuthor: () => getArticlesByAuthor,
   getArticlesByCategory: () => getArticlesByCategory,
+  getArticlesBySeries: () => getArticlesBySeries,
   getAuthorBySlug: () => getAuthorBySlug,
   getAvailableArticleSlugs: () => getAvailableArticleSlugs,
   getBreadcrumbsConfig: () => getBreadcrumbsConfig,
+  getContentSlotBoundaries: () => getContentSlotBoundaries,
+  getPath: () => getPath,
+  getPathArticles: () => getPathArticles,
+  getRelatedArticlesByCategory: () => getRelatedArticlesByCategory,
+  getRelatedContent: () => getRelatedContent,
+  getTotalPages: () => getTotalPages,
+  isPageOutOfRange: () => isPageOutOfRange,
   markdownToHtml: () => markdownToHtml,
+  paginateArticles: () => paginateArticles,
+  parsePageParam: () => parsePageParam,
   resolveAuthorAvatar: () => resolveAuthorAvatar,
+  resolveSearchMetadata: () => resolveSearchMetadata,
+  resolveSocialMetadata: () => resolveSocialMetadata,
   sanitizeImagePath: () => sanitizeImagePath2,
   searchArticles: () => searchArticles,
-  setArticlesErrorHandler: () => setArticlesErrorHandler
+  setArticlesErrorHandler: () => setArticlesErrorHandler,
+  validateAllArticles: () => validateAllArticles,
+  validateArticles: () => validateArticles
 });
 module.exports = __toCommonJS(server_exports);
 
@@ -126,6 +150,17 @@ var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
 var import_reading_time = __toESM(require("reading-time"), 1);
 
+// src/authorUtils.ts
+function getAuthorAvatar(author, config) {
+  if (!author.avatar) return void 0;
+  if (author.avatar.startsWith("http://") || author.avatar.startsWith("https://")) {
+    return author.avatar;
+  }
+  const path2 = `/articles/authors/${author.slug}/${author.avatar.replace(/^\/+/, "")}`;
+  if (!config) return path2;
+  return `${config.siteUrl.replace(/\/$/, "")}${path2}`;
+}
+
 // src/markdown.ts
 var import_rehype_prism_plus = __toESM(require("rehype-prism-plus"), 1);
 var import_rehype_sanitize = __toESM(require("rehype-sanitize"), 1);
@@ -448,6 +483,22 @@ function extractHeadingItem(node) {
   if (!id || !text) return null;
   return { id, depth: Number.parseInt(match[1], 10), text };
 }
+function getContentSlotBoundaries(markdown) {
+  var _a, _b, _c;
+  try {
+    const tree = (0, import_remark.remark)().use(import_remark_parse.default).use(import_remark_gfm.default).parse(markdown);
+    const paragraphs = ((_a = tree.children) != null ? _a : []).filter(
+      (node) => node.type === "paragraph" && Boolean(node.position)
+    );
+    if (paragraphs.length === 0) return null;
+    const introEnd = (_b = paragraphs[0].position.end.offset) != null ? _b : 0;
+    const midIndex = Math.floor(paragraphs.length / 2);
+    const mid = (_c = paragraphs[midIndex].position.end.offset) != null ? _c : introEnd;
+    return { introEnd, mid: Math.max(mid, introEnd), paragraphCount: paragraphs.length };
+  } catch (e) {
+    return null;
+  }
+}
 function extractToc(markdown) {
   return __async(this, null, function* () {
     const headings = [];
@@ -468,8 +519,9 @@ var articlesDirectory = import_node_path.default.join(
   process.cwd(),
   "public/articles"
 );
-function getReadingTime(content) {
-  return (0, import_reading_time.default)(content).text;
+function getReadingStats(content) {
+  const stats = (0, import_reading_time.default)(content);
+  return { readTime: stats.text, wordCount: stats.words };
 }
 function findArticleImage(slug) {
   try {
@@ -589,6 +641,23 @@ function parseHowToSteps(raw) {
   );
   return steps.length ? steps : void 0;
 }
+function parseOptionalString(raw) {
+  return typeof raw === "string" && raw.trim().length > 0 ? raw.trim() : void 0;
+}
+function parseSeriesOrder(raw) {
+  return typeof raw === "number" && Number.isFinite(raw) ? raw : void 0;
+}
+function parsePrimaryAction(raw) {
+  if (typeof raw === "string") {
+    const actionId = raw.trim();
+    return actionId ? { actionId } : void 0;
+  }
+  if (typeof raw === "object" && raw !== null && typeof raw.actionId === "string") {
+    const actionId = raw.actionId.trim();
+    return actionId ? { actionId } : void 0;
+  }
+  return void 0;
+}
 function parseAuthors(raw) {
   if (!Array.isArray(raw)) return void 0;
   const authors = raw.filter(
@@ -656,20 +725,26 @@ function getArticleSummary(slug, config) {
       if (!found) return null;
       const fileContent = import_node_fs.default.readFileSync(found.filePath, "utf8");
       const { data, content: markdownContent } = (0, import_gray_matter.default)(fileContent);
-      const readTime = getReadingTime(markdownContent);
+      const { readTime, wordCount } = getReadingStats(markdownContent);
       const allTags = Array.isArray(data.tags) ? data.tags.filter((t) => typeof t === "string" && String(t).trim()) : [];
       const categories = allTags.length > 0 ? allTags.map((t) => t.replaceAll("-", " ").trim()) : ["Campaigns"];
+      const author = resolveArticleAuthorName(data.author, data.authors, config);
+      const authors = parseAuthors(data.authors);
+      const primaryAuthorProfile = config ? getArticleAuthors({ author, authors }, config)[0] : void 0;
       return {
         slug,
         title: data.title || slug.replaceAll("-", " "),
         excerpt: data.excerpt || "",
         date: parseDateField(data.date),
         lastmod: parseDateField(data.lastmod),
-        author: resolveArticleAuthorName(data.author, data.authors, config),
-        authors: parseAuthors(data.authors),
+        author,
+        authors,
+        authorSlug: primaryAuthorProfile == null ? void 0 : primaryAuthorProfile.slug,
+        authorAvatar: primaryAuthorProfile ? getAuthorAvatar(primaryAuthorProfile, config) : void 0,
         category: categories[0],
         categories,
         readTime,
+        wordCount,
         featuredImage: resolveFeaturedImage(data.featuredImage, slug),
         tags: data.tags || [],
         contentType: found.contentType,
@@ -679,7 +754,15 @@ function getArticleSummary(slug, config) {
         canonicalUrl: typeof data.canonicalUrl === "string" ? data.canonicalUrl : void 0,
         articleType: typeof data.articleType === "string" ? data.articleType : void 0,
         series: typeof data.series === "string" ? data.series : void 0,
-        aiCrawl: data.aiCrawl === true
+        seriesSlug: parseOptionalString(data.seriesSlug),
+        seriesOrder: parseSeriesOrder(data.seriesOrder),
+        aiCrawl: data.aiCrawl === true,
+        searchTitle: parseOptionalString(data.searchTitle),
+        searchDescription: parseOptionalString(data.searchDescription),
+        socialTitle: parseOptionalString(data.socialTitle),
+        socialDescription: parseOptionalString(data.socialDescription),
+        socialImage: parseOptionalString(data.socialImage),
+        primaryAction: parsePrimaryAction(data.primaryAction)
       };
     } catch (error) {
       reportArticlesError({
@@ -859,6 +942,12 @@ function getArticlesByCategory(categorySlug, config) {
     );
   });
 }
+function getRelatedArticlesByCategory(currentSlug, category, limit = 3, config) {
+  return __async(this, null, function* () {
+    const articles = yield getArticlesByCategory(categoryToSlug(category), config);
+    return articles.filter((article) => article.slug !== currentSlug).slice(0, limit);
+  });
+}
 function getArticlesByAuthor(authorSlug, config) {
   return __async(this, null, function* () {
     const articles = yield getAllArticles(config);
@@ -867,6 +956,79 @@ function getArticlesByAuthor(authorSlug, config) {
     );
   });
 }
+function getArticlesBySeries(seriesSlug, config) {
+  return __async(this, null, function* () {
+    const articles = yield getAllArticles(config);
+    return articles.filter((article) => article.seriesSlug === seriesSlug).sort((a, b) => {
+      var _a, _b;
+      const orderA = (_a = a.seriesOrder) != null ? _a : Number.POSITIVE_INFINITY;
+      const orderB = (_b = b.seriesOrder) != null ? _b : Number.POSITIVE_INFINITY;
+      return orderA - orderB;
+    });
+  });
+}
+function getAdjacentArticlesInSeries(currentSlug, seriesSlug, config) {
+  return __async(this, null, function* () {
+    const seriesArticles = yield getArticlesBySeries(seriesSlug, config);
+    const currentIndex = seriesArticles.findIndex((article) => article.slug === currentSlug);
+    if (currentIndex === -1) return { previous: null, next: null };
+    return {
+      previous: currentIndex > 0 ? seriesArticles[currentIndex - 1] : null,
+      next: currentIndex < seriesArticles.length - 1 ? seriesArticles[currentIndex + 1] : null
+    };
+  });
+}
+function getPath(pathKey, config) {
+  var _a, _b;
+  return (_b = (_a = config.paths) == null ? void 0 : _a[pathKey]) != null ? _b : null;
+}
+function getPathArticles(pathKey, config) {
+  return __async(this, null, function* () {
+    const path2 = getPath(pathKey, config);
+    if (!path2) return [];
+    const articles = yield getAllArticles(config);
+    const bySlug = new Map(articles.map((article) => [article.slug, article]));
+    return path2.articles.map((slug) => bySlug.get(slug)).filter((article) => Boolean(article));
+  });
+}
+function findPathForArticle(slug, config) {
+  var _a;
+  for (const [key, path2] of Object.entries((_a = config.paths) != null ? _a : {})) {
+    if (path2.articles.includes(slug)) return { key, path: path2 };
+  }
+  return null;
+}
+function getRelatedContent(article, config, limit = 3) {
+  return __async(this, null, function* () {
+    var _a;
+    const matchedPath = findPathForArticle(article.slug, config);
+    if (matchedPath) {
+      const pathArticles = yield getPathArticles(matchedPath.key, config);
+      return {
+        source: "path",
+        heading: matchedPath.path.name,
+        articles: pathArticles.filter((a) => a.slug !== article.slug),
+        pathKey: matchedPath.key,
+        nextAction: matchedPath.path.nextAction
+      };
+    }
+    if (article.seriesSlug) {
+      const seriesArticles = yield getArticlesBySeries(article.seriesSlug, config);
+      return {
+        source: "series",
+        heading: (_a = article.series) != null ? _a : "This series",
+        articles: seriesArticles.filter((a) => a.slug !== article.slug)
+      };
+    }
+    const categoryArticles = yield getRelatedArticlesByCategory(
+      article.slug,
+      article.category,
+      limit,
+      config
+    );
+    return { source: "category", heading: `More in ${article.category}`, articles: categoryArticles };
+  });
+}
 
 // src/articlesConfig.ts
 function breadcrumbsAreEnabled(config) {
@@ -879,6 +1041,48 @@ function getBreadcrumbsConfig(config) {
   return (_a = config.breadcrumbs) != null ? _a : {};
 }
 
+// src/pagination.ts
+function getTotalPages(totalCount, pageSize) {
+  if (totalCount <= 0 || pageSize <= 0) return 1;
+  return Math.max(1, Math.ceil(totalCount / pageSize));
+}
+function paginateArticles(articles, page, pageSize) {
+  const totalPages = getTotalPages(articles.length, pageSize);
+  const requestedPage = Math.trunc(page) || 1;
+  const clampedPage = Math.min(Math.max(requestedPage, 1), totalPages);
+  const start = (clampedPage - 1) * pageSize;
+  return {
+    articles: articles.slice(start, start + pageSize),
+    page: clampedPage,
+    totalPages,
+    hasPrevious: clampedPage > 1,
+    hasNext: clampedPage < totalPages
+  };
+}
+function buildPageUrl(basePath, page) {
+  const base = basePath.replace(/\/$/, "");
+  return page > 1 ? `${base}/page/${page}` : base;
+}
+function buildPaginationLinks(basePath, page, totalPages) {
+  return {
+    canonicalUrl: buildPageUrl(basePath, page),
+    prevUrl: page > 1 ? buildPageUrl(basePath, page - 1) : null,
+    nextUrl: page < totalPages ? buildPageUrl(basePath, page + 1) : null
+  };
+}
+function generateListingPageStaticParams(totalPages) {
+  const params = [];
+  for (let page = 2; page <= totalPages; page++) params.push({ page: String(page) });
+  return params;
+}
+function parsePageParam(raw) {
+  const parsed = Number.parseInt(raw != null ? raw : "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 1;
+}
+function isPageOutOfRange(page, totalPages) {
+  return page < 1 || page > totalPages;
+}
+
 // src/seoUtils.ts
 function escapeXml(str) {
   return str.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
@@ -930,6 +1134,15 @@ function generateAuthorStaticParams(config) {
   if (config.showAuthorPage === false) return [];
   return getAllAuthors(config).map((author) => ({ author: author.slug }));
 }
+function generateSeriesStaticParams(config) {
+  return __async(this, null, function* () {
+    const articles = yield getAllArticles(config);
+    const seriesSlugs = new Set(
+      articles.map((article) => article.seriesSlug).filter((slug) => Boolean(slug))
+    );
+    return [...seriesSlugs].map((series) => ({ series }));
+  });
+}
 function resolveImageUrl(featuredImage, siteUrl) {
   const base = siteUrl.replace(/\/$/, "");
   if (featuredImage.startsWith("http://") || featuredImage.startsWith("https://")) {
@@ -937,9 +1150,25 @@ function resolveImageUrl(featuredImage, siteUrl) {
   }
   return `${base}/${featuredImage.replace(/^\/+/, "")}`;
 }
+function resolveSearchMetadata(article, config) {
+  var _a, _b, _c;
+  return {
+    title: (_a = article.searchTitle) != null ? _a : article.title,
+    description: (_c = (_b = article.searchDescription) != null ? _b : article.excerpt) != null ? _c : `Read ${article.title} on ${config.siteName}.`
+  };
+}
+function resolveSocialMetadata(article, siteUrl) {
+  var _a, _b, _c, _d;
+  const image = (_a = article.socialImage) != null ? _a : article.featuredImage;
+  return {
+    title: (_b = article.socialTitle) != null ? _b : article.title,
+    description: (_d = (_c = article.socialDescription) != null ? _c : article.excerpt) != null ? _d : "",
+    imageUrl: image ? resolveImageUrl(image, siteUrl) : `${siteUrl}/placeholder-logo.png`
+  };
+}
 function generateArticleMetadata(slug, config) {
   return __async(this, null, function* () {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f;
     const article = yield getArticleMetadata(slug, config);
     if (!article) {
       return {
@@ -950,31 +1179,32 @@ function generateArticleMetadata(slug, config) {
     const siteUrl = config.siteUrl.replace(/\/$/, "");
     const articleUrl = `${siteUrl}/articles/${slug}`;
     const canonicalUrl = (_a = article.canonicalUrl) != null ? _a : articleUrl;
-    const imageUrl = article.featuredImage ? resolveImageUrl(article.featuredImage, siteUrl) : `${siteUrl}/placeholder-logo.png`;
-    const description = (_b = article.excerpt) != null ? _b : `Read ${article.title} on ${config.siteName}.`;
+    const search = resolveSearchMetadata(article, config);
+    const social = resolveSocialMetadata(article, siteUrl);
+    const description = search.description;
     const showAuthor = config.showAuthor !== false;
     const markdownUrl = getArticleMarkdownUrl(article, config);
     const authorNames = getArticleAuthors(article, config).map((author) => author.name);
     return {
-      title: `${article.title} | ${config.siteName}`,
+      title: `${search.title} | ${config.siteName}`,
       description,
-      keywords: [...((_c = article.tags) != null ? _c : []).map((tag) => tag.toLowerCase())].join(", "),
+      keywords: [...((_b = article.tags) != null ? _b : []).map((tag) => tag.toLowerCase())].join(", "),
       openGraph: __spreadProps(__spreadValues(__spreadValues(__spreadValues({
-        title: article.title,
-        description,
+        title: social.title,
+        description: social.description || description,
         url: articleUrl,
         siteName: config.siteName,
-        images: [{ url: imageUrl, width: 1200, height: 630, alt: article.title }],
+        images: [{ url: social.imageUrl, width: 1200, height: 630, alt: social.title }],
         locale: "en_US",
         type: "article"
       }, article.date && { publishedTime: article.date }), article.lastmod && { modifiedTime: new Date(article.lastmod).toISOString() }), showAuthor && authorNames.length > 0 && { authors: authorNames }), {
-        tags: (_d = article.tags) != null ? _d : []
+        tags: (_c = article.tags) != null ? _c : []
       }),
       twitter: {
         card: "summary_large_image",
-        title: article.title,
-        description,
-        images: [imageUrl]
+        title: social.title,
+        description: social.description || description,
+        images: [social.imageUrl]
       },
       alternates: __spreadValues({
         canonical: canonicalUrl
@@ -1000,8 +1230,8 @@ function generateArticleMetadata(slug, config) {
         "article:modified_time": new Date(article.lastmod).toISOString()
       }), {
         "article:section": article.category,
-        "article:tag": (_f = (_e = article.tags) == null ? void 0 : _e.join(",")) != null ? _f : "",
-        "linkedin:owner": (_g = process.env.NEXT_PUBLIC_LINKEDIN_COMPANY_ID) != null ? _g : ""
+        "article:tag": (_e = (_d = article.tags) == null ? void 0 : _d.join(",")) != null ? _e : "",
+        "linkedin:owner": (_f = process.env.NEXT_PUBLIC_LINKEDIN_COMPANY_ID) != null ? _f : ""
       })
     };
   });
@@ -1093,6 +1323,50 @@ function generateCategoryMetadata(categorySlug, config) {
     };
   });
 }
+function generateSeriesMetadata(seriesSlug, config) {
+  return __async(this, null, function* () {
+    var _a;
+    const articles = yield getArticlesBySeries(seriesSlug, config);
+    if (articles.length === 0) return { title: "Series Not Found" };
+    const seriesName = (_a = articles[0].series) != null ? _a : seriesSlug;
+    const siteUrl = config.siteUrl.replace(/\/$/, "");
+    const seriesUrl = `${siteUrl}/articles/series/${seriesSlug}`;
+    const description = `Follow the ${seriesName} series - ${articles.length} article${articles.length === 1 ? "" : "s"} on ${config.siteName}.`;
+    const title = `${seriesName} Series | ${config.siteName}`;
+    return {
+      title,
+      description,
+      openGraph: {
+        title: `${seriesName} Series`,
+        description,
+        url: seriesUrl,
+        siteName: config.siteName,
+        images: [{ url: articles[0].featuredImage }],
+        type: "website",
+        locale: "en_US"
+      },
+      twitter: {
+        card: "summary_large_image",
+        title: `${seriesName} Series`,
+        description
+      },
+      alternates: {
+        canonical: seriesUrl
+      },
+      robots: {
+        index: true,
+        follow: true,
+        googleBot: {
+          index: true,
+          follow: true,
+          "max-video-preview": -1,
+          "max-image-preview": "large",
+          "max-snippet": -1
+        }
+      }
+    };
+  });
+}
 function generateAuthorMetadata(authorSlug, config) {
   return __async(this, null, function* () {
     var _a;
@@ -1127,6 +1401,47 @@ function generateAuthorMetadata(authorSlug, config) {
     };
   });
 }
+function withPaginationMeta(base, basePath, page, totalPages) {
+  if (!base.alternates) return base;
+  const { canonicalUrl } = buildPaginationLinks(basePath, page, totalPages);
+  const pageSuffix = page > 1 ? ` - Page ${page}` : "";
+  const title = typeof base.title === "string" ? `${base.title}${pageSuffix}` : base.title;
+  const openGraph = base.openGraph ? __spreadProps(__spreadValues({}, base.openGraph), {
+    title: typeof base.openGraph.title === "string" ? `${base.openGraph.title}${pageSuffix}` : base.openGraph.title,
+    url: canonicalUrl
+  }) : base.openGraph;
+  const twitter = base.twitter ? __spreadProps(__spreadValues({}, base.twitter), {
+    title: typeof base.twitter.title === "string" ? `${base.twitter.title}${pageSuffix}` : base.twitter.title
+  }) : base.twitter;
+  return __spreadProps(__spreadValues({}, base), {
+    title,
+    openGraph,
+    twitter,
+    alternates: __spreadProps(__spreadValues({}, base.alternates), { canonical: canonicalUrl })
+  });
+}
+function generateArticlesIndexPageMetadata(page, totalPages, config) {
+  const base = generateArticlesIndexMetadata(config);
+  const siteUrl = config.siteUrl.replace(/\/$/, "");
+  return withPaginationMeta(base, `${siteUrl}/articles`, page, totalPages);
+}
+function generateCategoryPageMetadata(categorySlug, page, totalPages, config) {
+  return __async(this, null, function* () {
+    const base = yield generateCategoryMetadata(categorySlug, config);
+    const siteUrl = config.siteUrl.replace(/\/$/, "");
+    return withPaginationMeta(base, `${siteUrl}/articles/category/${categorySlug}`, page, totalPages);
+  });
+}
+function generateAuthorPageMetadata(authorSlug, page, totalPages, config) {
+  return __async(this, null, function* () {
+    var _a;
+    const base = yield generateAuthorMetadata(authorSlug, config);
+    const author = getAuthorBySlug(authorSlug, config);
+    const siteUrl = config.siteUrl.replace(/\/$/, "");
+    const basePath = (_a = author == null ? void 0 : author.url) != null ? _a : `${siteUrl}/articles/authors/${authorSlug}`;
+    return withPaginationMeta(base, basePath, page, totalPages);
+  });
+}
 function formatCategoryName(category) {
   return category.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
 }
@@ -1317,13 +1632,91 @@ function renderMdxSource(source, basePath, config) {
 
 // src/ArticleContent.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
+function buildSlotContext(article) {
+  var _a, _b;
+  return {
+    slug: article.slug,
+    title: article.title,
+    category: article.category,
+    tags: (_a = article.tags) != null ? _a : [],
+    readTime: article.readTime,
+    wordCount: article.wordCount,
+    authorSlug: article.authorSlug,
+    seriesSlug: article.seriesSlug,
+    primaryActionId: (_b = article.primaryAction) == null ? void 0 : _b.actionId
+  };
+}
+function resolveSlot(slot, context) {
+  if (slot === void 0) return null;
+  return typeof slot === "function" ? slot(context) : slot;
+}
+function renderSegment(markdown, contentType, slug, config) {
+  return __async(this, null, function* () {
+    if (!markdown.trim()) return null;
+    if (contentType === "mdx") {
+      return renderMdxSource(markdown, `/articles/${slug}`, config);
+    }
+    const html = yield markdownToHtml(markdown, slug, config);
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { dangerouslySetInnerHTML: { __html: html } });
+  });
+}
 function ArticleContent(_0) {
-  return __async(this, arguments, function* ({ article, className, config }) {
-    if (article.contentType === "mdx" && article.mdxSource) {
-      const content = yield renderMdxSource(article.mdxSource, `/articles/${article.slug}`, config);
-      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className, children: content });
+  return __async(this, arguments, function* ({
+    article,
+    className,
+    config,
+    afterHero,
+    afterIntro,
+    midContent,
+    afterContent
+  }) {
+    var _a;
+    const hasAnySlot = afterHero !== void 0 || afterIntro !== void 0 || midContent !== void 0 || afterContent !== void 0;
+    if (!hasAnySlot) {
+      if (article.contentType === "mdx" && article.mdxSource) {
+        const content = yield renderMdxSource(article.mdxSource, `/articles/${article.slug}`, config);
+        return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className, children: content });
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className, dangerouslySetInnerHTML: { __html: article.htmlContent || "" } });
+    }
+    const slotContext = buildSlotContext(article);
+    const heroNode = resolveSlot(afterHero, slotContext);
+    const introNode = resolveSlot(afterIntro, slotContext);
+    const midNode = resolveSlot(midContent, slotContext);
+    const contentNode = resolveSlot(afterContent, slotContext);
+    const needsSplit = Boolean(introNode || midNode);
+    const rawSource = article.contentType === "mdx" ? article.mdxSource : (_a = article.content) != null ? _a : void 0;
+    if (needsSplit && rawSource) {
+      const boundaries = getContentSlotBoundaries(rawSource);
+      if (boundaries) {
+        try {
+          const introSegment = rawSource.slice(0, boundaries.introEnd);
+          const midSegment = rawSource.slice(boundaries.introEnd, boundaries.mid);
+          const restSegment = rawSource.slice(boundaries.mid);
+          const [introHtml, midHtml, restHtml] = yield Promise.all([
+            renderSegment(introSegment, article.contentType, article.slug, config),
+            renderSegment(midSegment, article.contentType, article.slug, config),
+            renderSegment(restSegment, article.contentType, article.slug, config)
+          ]);
+          return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className, children: [
+            heroNode,
+            introHtml,
+            introNode,
+            midHtml,
+            midNode,
+            restHtml,
+            contentNode
+          ] });
+        } catch (e) {
+        }
+      }
     }
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className, dangerouslySetInnerHTML: { __html: article.htmlContent || "" } });
+    const wholeBody = article.contentType === "mdx" && article.mdxSource ? yield renderMdxSource(article.mdxSource, `/articles/${article.slug}`, config) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { dangerouslySetInnerHTML: { __html: article.htmlContent || "" } });
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className, children: [
+      heroNode,
+      wholeBody,
+      contentNode
+    ] });
   });
 }
 
@@ -1350,6 +1743,227 @@ function ArticleTOC({ toc, className }) {
     }
   );
 }
+
+// src/validateArticles.ts
+var UNSAFE_URL_SCHEME = /^\s*(javascript|data|vbscript):/i;
+var SEARCH_TITLE_MAX = 60;
+var SEARCH_DESCRIPTION_MAX = 160;
+var SOCIAL_TITLE_MAX = 95;
+var SOCIAL_DESCRIPTION_MAX = 200;
+function isUnsafeUrl(href) {
+  return UNSAFE_URL_SCHEME.test(href);
+}
+function checkDuplicateCanonicalUrls(articles) {
+  const seen = /* @__PURE__ */ new Map();
+  const issues = [];
+  for (const article of articles) {
+    if (!article.canonicalUrl) continue;
+    const owner = seen.get(article.canonicalUrl);
+    if (owner) {
+      issues.push({
+        severity: "error",
+        code: "duplicate-canonical-url",
+        message: `canonicalUrl "${article.canonicalUrl}" is also used by "${owner}".`,
+        articleSlug: article.slug
+      });
+    } else {
+      seen.set(article.canonicalUrl, article.slug);
+    }
+  }
+  return issues;
+}
+function checkAuthorReferences(articles, config) {
+  if (!config.authors || Object.keys(config.authors).length === 0) return [];
+  const issues = [];
+  for (const article of articles) {
+    for (const resolved of getArticleAuthors(article, config)) {
+      if (!getAuthorBySlug(resolved.slug, config)) {
+        issues.push({
+          severity: "error",
+          code: "unknown-author-reference",
+          message: `Author "${resolved.name}" does not match any entry in config.authors.`,
+          articleSlug: article.slug
+        });
+      }
+    }
+  }
+  return issues;
+}
+function checkSeriesCollisions(articles) {
+  const issues = [];
+  const seenSlugOrder = /* @__PURE__ */ new Map();
+  for (const article of articles) {
+    if (!article.seriesSlug || article.seriesOrder === void 0) continue;
+    const key = `${article.seriesSlug}::${article.seriesOrder}`;
+    const owner = seenSlugOrder.get(key);
+    if (owner) {
+      issues.push({
+        severity: "error",
+        code: "duplicate-series-order",
+        message: `seriesOrder ${article.seriesOrder} in series "${article.seriesSlug}" collides with "${owner}".`,
+        articleSlug: article.slug
+      });
+    } else {
+      seenSlugOrder.set(key, article.slug);
+    }
+  }
+  return issues;
+}
+function checkPaths(articles, config) {
+  var _a;
+  const issues = [];
+  const bySlug = new Map(articles.map((article) => [article.slug, article]));
+  for (const [pathKey, path2] of Object.entries((_a = config.paths) != null ? _a : {})) {
+    if (path2.articles.length === 0) {
+      issues.push({
+        severity: "error",
+        code: "empty-path",
+        message: `Path "${pathKey}" has no articles.`,
+        pathKey
+      });
+    }
+    for (const slug of path2.articles) {
+      const referenced = bySlug.get(slug);
+      if (!referenced) {
+        issues.push({
+          severity: "error",
+          code: "path-missing-article",
+          message: `Path "${pathKey}" references missing article "${slug}".`,
+          pathKey,
+          articleSlug: slug
+        });
+      } else if (referenced.draft) {
+        issues.push({
+          severity: "error",
+          code: "path-references-draft",
+          message: `Path "${pathKey}" references unpublished (draft) article "${slug}".`,
+          pathKey,
+          articleSlug: slug
+        });
+      }
+    }
+    if (isUnsafeUrl(path2.nextAction.href)) {
+      issues.push({
+        severity: "error",
+        code: "unsafe-url",
+        message: `Path "${pathKey}" nextAction.href uses an unsafe URL scheme.`,
+        pathKey
+      });
+    }
+  }
+  return issues;
+}
+function checkAuthorCtaUrls(config) {
+  var _a;
+  const issues = [];
+  for (const author of Object.values((_a = config.authors) != null ? _a : {})) {
+    if (author.primaryCta && isUnsafeUrl(author.primaryCta.href)) {
+      issues.push({
+        severity: "error",
+        code: "unsafe-url",
+        message: `Author "${author.slug}" primaryCta.href uses an unsafe URL scheme.`
+      });
+    }
+  }
+  return issues;
+}
+function checkRequiredFrontmatter(articles) {
+  const issues = [];
+  for (const article of articles) {
+    if (!article.excerpt) {
+      issues.push({
+        severity: "warning",
+        code: "missing-excerpt",
+        message: "Article has no excerpt.",
+        articleSlug: article.slug
+      });
+    }
+    if (!article.date) {
+      issues.push({
+        severity: "warning",
+        code: "missing-date",
+        message: "Article has no date.",
+        articleSlug: article.slug
+      });
+    }
+  }
+  return issues;
+}
+function checkDiscoveryFieldLengths(articles) {
+  const issues = [];
+  for (const article of articles) {
+    const checks = [
+      [article.searchTitle, "search-title-too-long", SEARCH_TITLE_MAX],
+      [article.searchDescription, "search-description-too-long", SEARCH_DESCRIPTION_MAX],
+      [article.socialTitle, "social-title-too-long", SOCIAL_TITLE_MAX],
+      [article.socialDescription, "social-description-too-long", SOCIAL_DESCRIPTION_MAX]
+    ];
+    for (const [value, code, max] of checks) {
+      if (value && value.length > max) {
+        issues.push({
+          severity: "warning",
+          code,
+          message: `${code.replaceAll("-", " ")} (${value.length} > ${max} recommended chars).`,
+          articleSlug: article.slug
+        });
+      }
+    }
+  }
+  return issues;
+}
+function checkCategorySlugs(articles) {
+  var _a;
+  const issues = [];
+  const slugToNames = /* @__PURE__ */ new Map();
+  for (const article of articles) {
+    for (const category of article.categories) {
+      const slug = categoryToSlug(category);
+      const names = (_a = slugToNames.get(slug)) != null ? _a : /* @__PURE__ */ new Set();
+      names.add(category);
+      slugToNames.set(slug, names);
+    }
+  }
+  for (const [slug, names] of slugToNames) {
+    if (names.size > 1) {
+      issues.push({
+        severity: "warning",
+        code: "category-slug-collision",
+        message: `Categories [${[...names].join(", ")}] all collapse to slug "${slug}".`
+      });
+    }
+  }
+  return issues;
+}
+function validateArticles(articles, config) {
+  const errors = [
+    ...checkDuplicateCanonicalUrls(articles),
+    ...checkAuthorReferences(articles, config),
+    ...checkSeriesCollisions(articles),
+    ...checkPaths(articles, config),
+    ...checkAuthorCtaUrls(config)
+  ];
+  const warnings = [
+    ...checkRequiredFrontmatter(articles),
+    ...checkDiscoveryFieldLengths(articles),
+    ...checkCategorySlugs(articles)
+  ];
+  return { ok: errors.length === 0, errors, warnings };
+}
+function validateAllArticles(config) {
+  return __async(this, null, function* () {
+    const articles = yield getAllArticles(config);
+    return validateArticles(articles, config);
+  });
+}
+
+// src/events.ts
+function emitArticleEvent(handler, event) {
+  if (!handler) return;
+  try {
+    handler(__spreadProps(__spreadValues({}, event), { timestamp: Date.now() }));
+  } catch (e) {
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArticleContent,
@@ -1357,17 +1971,27 @@ function ArticleTOC({ toc, className }) {
   buildArticleBreadcrumbs,
   buildAuthorBreadcrumbs,
   buildCategoryBreadcrumbs,
+  buildPageUrl,
+  buildPaginationLinks,
   categoryToSlug,
+  emitArticleEvent,
   extractToc,
   generateArticleMetadata,
   generateArticleStaticParams,
   generateArticlesIndexMetadata,
+  generateArticlesIndexPageMetadata,
   generateAuthorMetadata,
+  generateAuthorPageMetadata,
   generateAuthorStaticParams,
   generateCategoryMetadata,
+  generateCategoryPageMetadata,
   generateCategoryStaticParams,
+  generateListingPageStaticParams,
   generateRssFeed,
+  generateSeriesMetadata,
+  generateSeriesStaticParams,
   getAdjacentArticles,
+  getAdjacentArticlesInSeries,
   getAiRobotsTxtRules,
   getAllArticles,
   getAllAuthors,
@@ -1381,13 +2005,27 @@ function ArticleTOC({ toc, className }) {
   getArticleSitemapEntries,
   getArticlesByAuthor,
   getArticlesByCategory,
+  getArticlesBySeries,
   getAuthorBySlug,
   getAvailableArticleSlugs,
   getBreadcrumbsConfig,
+  getContentSlotBoundaries,
+  getPath,
+  getPathArticles,
+  getRelatedArticlesByCategory,
+  getRelatedContent,
+  getTotalPages,
+  isPageOutOfRange,
   markdownToHtml,
+  paginateArticles,
+  parsePageParam,
   resolveAuthorAvatar,
+  resolveSearchMetadata,
+  resolveSocialMetadata,
   sanitizeImagePath,
   searchArticles,
-  setArticlesErrorHandler
+  setArticlesErrorHandler,
+  validateAllArticles,
+  validateArticles
 });
 //# sourceMappingURL=server.cjs.map