@roottale/cms-renderer-next 0.35.0 → 0.37.0

package/dist/routes.d.ts

@@ -70,21 +70,66 @@ declare function createFeedRoute(config: RootTaleSiteConfig): () => Promise<Resp
 interface SitemapEntry {
     url: string;
     lastModified?: string | Date;
+    /** @deprecated Google 이 무시 — emit 하지 않는다(blanche식 loc+lastmod). */
     changeFrequency?: "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+    /** @deprecated Google 이 무시 — emit 하지 않는다. */
     priority?: number;
+    /** `<image:image>` — 글 대표 이미지 등. Next `MetadataRoute.Sitemap` 호환. */
+    images?: string[];
+    /** hreflang 대체 언어 — 다국어(`alternates.languages`). Next 호환. */
+    alternates?: {
+        languages?: Record<string, string>;
+    };
+}
+/** `createSitemapIndex` 옵션 — admin 설정을 코드에서 덮어쓰거나 fetch 를 끌 때만. */
+interface SitemapIndexOptions {
+    /** admin 의 `blogImages` 토글을 덮어쓴다. */
+    blogImages?: boolean;
+    /** admin 의 `locales` 를 덮어쓴다 (다국어, PR C). */
+    locales?: string[];
+    /** admin 의 `authors` 토글을 덮어쓴다 (작가 사이트맵). */
+    authors?: boolean;
+    /** 작가 아카이브 base path. 기본 "/blog/author" (→ /blog/author/{slug}). */
+    authorBasePath?: string;
+    /** true 면 admin 설정 fetch 생략(opts/기본값만). 빌드 시 네트워크 회피용. */
+    skipRemoteSettings?: boolean;
 }
 /**
- * `app/sitemap.ts` default export. 정적 경로 + 글 경로를 합친다.
+ * @deprecated `createSitemapIndex` 를 쓰세요 — 단일 평면 사이트맵 대신 인덱스 분리
+ * (static/blog/categories) + 이미지 + admin 토글을 지원한다. 본 함수는 하위호환용으로
+ * 유지되며 `changeFrequency`/`priority` 는 더 이상 emit 하지 않는다(blanche식).
+ *
+ * `app/sitemap.ts` default export. 정적 경로 + 글 + 카테고리를 단일 파일로 합친다.
+ */
+declare function createSitemap(config: RootTaleSiteConfig, staticRoutes?: SitemapEntry[]): () => Promise<SitemapEntry[]>;
+/** blanche식 인덱스 분리 사이트맵의 하위 섹션 id. */
+type SitemapSectionId = "static" | "blog" | "categories" | "authors";
+/**
+ * blanche식 사이트맵 인덱스 — `/sitemap.xml`(인덱스) + `/sitemap/<id>.xml` 하위
+ * 사이트맵(static/blog/categories)으로 분리한다(Next 16 `generateSitemaps`). 50k
+ * URL/50MB 한도 확장 + 검색엔진이 섹션별로 크롤. 블로그 글에는 대표 이미지를
+ * `<image:image>` 로 함께 색인(admin 토글). `changeFrequency`/`priority` 는 emit
+ * 하지 않는다.
  *
  * ```ts
- * import { createSitemap } from "@roottale/cms-renderer-next/routes";
- * export default createSitemap(
+ * // app/sitemap.ts
+ * import { createSitemapIndex } from "@roottale/cms-renderer-next/routes";
+ * const { generateSitemaps, sitemap } = createSitemapIndex(
  *   { apiKey: process.env.ROOTTALE_API_KEY!, siteUrl: "https://example.com", title: "..." },
- *   [{ url: "https://example.com", changeFrequency: "weekly", priority: 1 }],
+ *   [{ url: "https://example.com" }, { url: "https://example.com/contact" }],
  * );
+ * export { generateSitemaps };
+ * export default sitemap;
  * ```
  */
-declare function createSitemap(config: RootTaleSiteConfig, staticRoutes?: SitemapEntry[]): () => Promise<SitemapEntry[]>;
+declare function createSitemapIndex(config: RootTaleSiteConfig, staticRoutes?: SitemapEntry[], opts?: SitemapIndexOptions): {
+    generateSitemaps: () => Promise<{
+        id: SitemapSectionId;
+    }[]>;
+    sitemap: (props: {
+        id: string | Promise<string>;
+    }) => Promise<SitemapEntry[]>;
+};
 
 /** `routes` — llms.txt (AEO/GEO, AI 검색·생성엔진용 마크다운 인덱스). */
 
@@ -146,7 +191,8 @@ interface RevalidateRouteConfig {
      * 모든 글/분류/미디어 변경에 대해 *항상 함께* revalidate 할 파생 경로.
      * 피드·사이트맵·블로그 인덱스처럼 "글 목록"에 의존하는 경로 — admin 변경이
      * 자동 반영되려면 필수. 명시 시 collections 파생을 덮어쓴다.
-     * 기본(레거시): ["/feed.xml", "/sitemap.xml", "/llms.txt", blogBase, `${blogBase}/categories`].
+     * 기본(레거시): ["/feed.xml", "/llms.txt", "/sitemap.xml", "/sitemap/static.xml",
+     * "/sitemap/blog.xml", "/sitemap/categories.xml", blogBase, `${blogBase}/categories`].
      */
     alsoRevalidate?: string[];
     /** (옵션) jti replay 방지 hook (cms-client verify 로 전달). */
@@ -306,6 +352,124 @@ declare function matchRedirect(redirects: readonly RootTaleRedirect[], pathname:
  */
 declare function createRedirectMiddleware(config: RedirectMiddlewareConfig): (request: Request) => Promise<Response | null>;
 
+/**
+ * `@roottale/cms-renderer-next/routes` — 블로그 글 메타데이터 빌더.
+ *
+ * 어드민 SEO 패널(`metaJson.seo`) 값을 Next.js `Metadata` 형태로 1줄 변환한다.
+ * 고객사 `app/blog/[slug]/page.tsx` 의 `generateMetadata` 에서 매번 직접 쓰던
+ * canonical/robots/openGraph 분기 보일러플레이트를 표준화 — 한 곳이라도
+ * 빠뜨려 SEO 가 새는 사고(noindex 누락·canonical 미설정)를 방지한다.
+ *
+ * 설계 원칙(패키지 공통): `next` 에 직접 의존하지 않는다. 반환은 Next `Metadata`
+ * 의 구조적 부분집합인 plain 객체이므로, 소비자는 `generateMetadata` 에서 그대로
+ * `return` 하면 된다.
+ */
+
+/** 어드민 SEO 패널 override (`metaJson.seo`). 전부 선택. */
+interface PostSeoOverrides {
+    /** 검색 제목 — 비면 글 제목 사용. */
+    title?: string;
+    /** 메타 설명 — 비면 글 요약 사용. */
+    description?: string;
+    /** 대표 URL. 비면 `siteUrl`+`path` 로 self-canonical 생성(옵션 제공 시). */
+    canonical?: string;
+    /** OG 이미지 — 비면 글 대표 이미지 사용. */
+    ogImage?: string;
+    /** 색인 제외. */
+    noindex?: boolean;
+    /** 링크 추적 제외. */
+    nofollow?: boolean;
+}
+/** `buildPostMetadata` 입력 — `BlogPostMeta`·원본 post 모두 구조적으로 호환. */
+interface PostMetadataInput {
+    /** 글 제목 (`seo.title` 없을 때 fallback). */
+    title: string;
+    /** 글 요약/설명 (`seo.description` 없을 때 fallback). */
+    description?: string | null;
+    /** 발행 ISO 일시 → `openGraph.publishedTime`. */
+    date?: string | null;
+    /** 대표 이미지 URL → `openGraph.images` (`seo.ogImage` 우선). */
+    image?: string | null;
+    /** 어드민 SEO 패널 override (`metaJson.seo`). */
+    seo?: PostSeoOverrides | null;
+    /** 글 slug — `collections` 기반 canonical 자동 해석에 사용. */
+    slug?: string;
+    /**
+     * 소속 섹션 key (ADR-0060). `collections` 와 함께 주면 canonical basePath 를
+     * 공지/블로그로 구분해 해석한다(`collectionKey:"notice"` → `/notice`).
+     */
+    collectionKey?: string | null;
+}
+interface BuildPostMetadataOptions {
+    /**
+     * self-canonical 기본값 origin (예: `https://example.com`).
+     * `seo.canonical` override 가 있으면 무시된다. `path` 또는 `collections` 와
+     * 함께 줄 때만 동작.
+     */
+    siteUrl?: string;
+    /**
+     * self-canonical 기본값 경로 (예: `/blog/my-post`). `siteUrl` 과 함께.
+     * 명시하면 `collections` 파생보다 우선한다(단일 라우트 사이트용 명시 경로).
+     */
+    path?: string;
+    /**
+     * 섹션 정의 (ADR-0060). `path` 를 안 주면 글의 `collectionKey` 로 소속 섹션
+     * basePath 를 찾아 canonical 경로를 **공지/블로그로 구분해 자동 해석**한다
+     * (공지 글 → `/notice/{slug}`, 블로그 글 → `/blog/{slug}`). 어느 섹션에도
+     * 안 속하면(미설정·미존재 key) canonical 을 생략한다. `post.slug` 필요.
+     */
+    collections?: readonly RouteCollection[];
+}
+/** Next `Metadata` 의 구조적 부분집합 — 소비자는 그대로 return 가능. */
+interface PostMetadata {
+    title: string;
+    description?: string;
+    alternates?: {
+        canonical: string;
+    };
+    robots?: {
+        index: boolean;
+        follow: boolean;
+    };
+    openGraph: {
+        type: "article";
+        title: string;
+        description?: string;
+        url?: string;
+        publishedTime?: string;
+        images?: {
+            url: string;
+            alt: string;
+        }[];
+    };
+}
+/**
+ * 글 메타데이터를 Next `Metadata` 형태로 빌드.
+ *
+ * - 제목/설명/OG 이미지는 어드민 SEO override 가 있으면 우선, 없으면 글 값 fallback.
+ * - canonical: `seo.canonical` override → 없으면 `siteUrl`+`path`(명시) → 없으면
+ *   `siteUrl`+`collections`(글의 `collectionKey` 로 공지/블로그 basePath 자동 해석)
+ *   → 없으면 생략. 모든 글이 자기 자신을 가리키는 canonical 을 갖는 게 권장이므로
+ *   `siteUrl` 과 함께 `path` 또는 `collections` 전달을 권장한다.
+ * - `noindex`/`nofollow` 중 하나라도 켜지면 `robots` 출력.
+ *
+ * ```ts
+ * // 단일 블로그(레거시): 라우트가 곧 섹션이므로 path 를 직접 준다.
+ * return buildPostMetadata(post, {
+ *   siteUrl: process.env.NEXT_PUBLIC_SITE_URL,
+ *   path: `/blog/${post.slug}`,
+ * });
+ *
+ * // 다중 스트림(ADR-0060): collections 를 주면 공지/블로그를 글의
+ * // collectionKey 로 구분해 canonical 을 자동 해석한다(공지→/notice, 블로그→/blog).
+ * return buildPostMetadata(post, {
+ *   siteUrl: process.env.NEXT_PUBLIC_SITE_URL,
+ *   collections: COLLECTIONS,
+ * });
+ * ```
+ */
+declare function buildPostMetadata(post: PostMetadataInput, options?: BuildPostMetadataOptions): PostMetadata;
+
 /**
  * `@roottale/cms-renderer-next/routes` — Next.js App Router 통합 라우트 팩토리.
  *
@@ -365,4 +529,4 @@ interface FleetInfoRouteConfig {
  */
 declare function createFleetInfoRoute(config?: FleetInfoRouteConfig): () => Promise<Response>;
 
-export { type CollectionsInput, type FleetInfoRouteConfig, type ImageResponseLike, type LlmsTxtLink, type LlmsTxtRouteConfig, type LlmsTxtSection, OG_IMAGE_CONTENT_TYPE, OG_IMAGE_SIZE, type OgImageRouteConfig, type RedirectMiddlewareConfig, type RevalidateRouteConfig, type RootTaleSiteConfig, type SitemapEntry, createFeedRoute, createFleetInfoRoute, createLlmsTxtRoute, createPostOgImage, createRedirectMiddleware, createRevalidateRoute, createSitemap, matchRedirect, normalizeRedirectPath, postRedirectPath, resolveCollections, resolveCollectionsResult, safeFetchPosts, trimSlash };
+export { type BuildPostMetadataOptions, type CollectionsInput, type FleetInfoRouteConfig, type ImageResponseLike, type LlmsTxtLink, type LlmsTxtRouteConfig, type LlmsTxtSection, OG_IMAGE_CONTENT_TYPE, OG_IMAGE_SIZE, type OgImageRouteConfig, type PostMetadata, type PostMetadataInput, type PostSeoOverrides, type RedirectMiddlewareConfig, type RevalidateRouteConfig, type RootTaleSiteConfig, type SitemapEntry, type SitemapIndexOptions, type SitemapSectionId, buildPostMetadata, createFeedRoute, createFleetInfoRoute, createLlmsTxtRoute, createPostOgImage, createRedirectMiddleware, createRevalidateRoute, createSitemap, createSitemapIndex, matchRedirect, normalizeRedirectPath, postRedirectPath, resolveCollections, resolveCollectionsResult, safeFetchPosts, trimSlash };

package/dist/routes.js

@@ -1,7 +1,7 @@
 import {
   collectCategories,
   collectCollectionCategories
-} from "./chunk-O6KHDNGH.js";
+} from "./chunk-FUA5H6JE.js";
 
 // src/routes.ts
 import { CMS_CLIENT_VERSION } from "@roottale/cms-client/server";
@@ -45,7 +45,12 @@ async function safeFetchPosts(config, limit) {
 }
 
 // src/routes-feed-sitemap.ts
-import { generateRssXml, rssItemsFromPosts } from "@roottale/cms-client/server";
+import {
+  fetchAuthors,
+  fetchBlogSettings,
+  generateRssXml,
+  rssItemsFromPosts
+} from "@roottale/cms-client/server";
 import {
   isInCollectionMode,
   resolvePostCollection as resolvePostCollection2,
@@ -80,62 +85,152 @@ function createFeedRoute(config) {
     });
   };
 }
+var SITEMAP_DEFAULTS = {
+  blogImages: true,
+  locales: [],
+  authors: false
+};
+async function safeFetchAuthors(config) {
+  try {
+    return await fetchAuthors({ apiKey: config.apiKey, baseUrl: config.apiBase });
+  } catch (err) {
+    console.error("[@roottale/cms-renderer-next/routes] fetchAuthors \uC2E4\uD328:", err);
+    return [];
+  }
+}
+async function resolveSitemapSettings(config, opts) {
+  let remote = {};
+  if (!opts.skipRemoteSettings) {
+    try {
+      remote = (await fetchBlogSettings({
+        apiKey: config.apiKey,
+        baseUrl: config.apiBase
+      })).sitemap ?? {};
+    } catch {
+    }
+  }
+  return {
+    blogImages: opts.blogImages ?? remote.blogImages ?? SITEMAP_DEFAULTS.blogImages,
+    locales: opts.locales ?? remote.locales ?? SITEMAP_DEFAULTS.locales,
+    authors: opts.authors ?? remote.authors ?? SITEMAP_DEFAULTS.authors
+  };
+}
+function localizeEntries(entries, siteUrl, locales) {
+  const defaultLocale = locales[0];
+  if (!defaultLocale) return entries;
+  const rest = locales.slice(1);
+  return entries.map((entry) => {
+    if (entry.url !== siteUrl && !entry.url.startsWith(`${siteUrl}/`)) return entry;
+    const path = entry.url.slice(siteUrl.length);
+    const languages = {
+      [defaultLocale]: entry.url,
+      "x-default": entry.url
+    };
+    for (const loc of rest) languages[loc] = `${siteUrl}/${loc}${path}`;
+    return { ...entry, alternates: { languages } };
+  });
+}
+function staticEntries(staticRoutes) {
+  return staticRoutes.map((r) => {
+    const entry = { url: r.url };
+    if (r.lastModified !== void 0) entry.lastModified = r.lastModified;
+    if (r.images) entry.images = r.images;
+    if (r.alternates) entry.alternates = r.alternates;
+    return entry;
+  });
+}
+function postEntries(config, siteUrl, posts, collections, settings) {
+  const inCollection = isInCollectionMode(collections);
+  const blogBase = config.blogBasePath ?? "/blog";
+  return posts.flatMap((p) => {
+    const url = inCollection ? resolvePostUrl2(siteUrl, p, collections) : `${siteUrl}${blogBase}/${p.slug}`;
+    if (!url) return [];
+    const entry = {
+      url,
+      lastModified: p.updatedAt ?? p.publishedAt ?? void 0
+    };
+    if (settings.blogImages && p.featuredImageUrl) {
+      entry.images = [p.featuredImageUrl];
+    }
+    return [entry];
+  });
+}
+function categoryEntries(config, siteUrl, posts, collections) {
+  if (isInCollectionMode(collections)) {
+    return collections.filter((c) => c.archives).flatMap((c) => {
+      const cats = collectCollectionCategories(posts, collections, c.key);
+      if (!cats.length) return [];
+      const base = `${siteUrl}${trimSlash(c.basePath)}`;
+      return [
+        { url: `${base}/categories` },
+        ...cats.map((category) => ({
+          url: `${base}/categories/${category.slug}`
+        }))
+      ];
+    });
+  }
+  const categories = collectCategories(posts);
+  if (!categories.length) return [];
+  const blogBase = config.blogBasePath ?? "/blog";
+  return [
+    { url: `${siteUrl}${blogBase}/categories` },
+    ...categories.map((category) => ({
+      url: `${siteUrl}${blogBase}/categories/${category.slug}`
+    }))
+  ];
+}
 function createSitemap(config, staticRoutes = []) {
   return async function sitemap() {
     const siteUrl = trimSlash(config.siteUrl);
-    const blogBase = config.blogBasePath ?? "/blog";
     const collections = await resolveCollections(config.collections);
     const posts = await safeFetchPosts(config, 200);
-    if (isInCollectionMode(collections)) {
-      const postEntries2 = posts.flatMap((p) => {
-        const url = resolvePostUrl2(siteUrl, p, collections);
-        if (!url) return [];
-        return [
-          {
-            url,
-            lastModified: p.updatedAt ?? p.publishedAt ?? void 0,
-            changeFrequency: "weekly",
-            priority: 0.6
-          }
-        ];
-      });
-      const categoryEntries2 = collections.filter((c) => c.archives).flatMap((c) => {
-        const cats = collectCollectionCategories(posts, collections, c.key);
-        if (!cats.length) return [];
-        const base = `${siteUrl}${trimSlash(c.basePath)}`;
-        return [
-          { url: `${base}/categories`, changeFrequency: "weekly", priority: 0.5 },
-          ...cats.map((category) => ({
-            url: `${base}/categories/${category.slug}`,
-            changeFrequency: "weekly",
-            priority: 0.5
-          }))
-        ];
-      });
-      return [...staticRoutes, ...postEntries2, ...categoryEntries2];
-    }
-    const postEntries = posts.map((p) => ({
-      url: `${siteUrl}${blogBase}/${p.slug}`,
-      lastModified: p.updatedAt ?? p.publishedAt ?? void 0,
-      changeFrequency: "weekly",
-      priority: 0.6
-    }));
-    const categories = collectCategories(posts);
-    const categoryEntries = categories.length ? [
-      {
-        url: `${siteUrl}${blogBase}/categories`,
-        changeFrequency: "weekly",
-        priority: 0.5
-      },
-      ...categories.map((category) => ({
-        url: `${siteUrl}${blogBase}/categories/${category.slug}`,
-        changeFrequency: "weekly",
-        priority: 0.5
-      }))
-    ] : [];
-    return [...staticRoutes, ...postEntries, ...categoryEntries];
+    const settings = await resolveSitemapSettings(config, {
+      skipRemoteSettings: true,
+      blogImages: false
+    });
+    return [
+      ...staticEntries(staticRoutes),
+      ...postEntries(config, siteUrl, posts, collections, settings),
+      ...categoryEntries(config, siteUrl, posts, collections)
+    ];
   };
 }
+function createSitemapIndex(config, staticRoutes = [], opts = {}) {
+  async function generateSitemaps() {
+    const settings = await resolveSitemapSettings(config, opts);
+    const ids = ["static", "blog", "categories"];
+    if (settings.authors) ids.push("authors");
+    return ids.map((id) => ({ id }));
+  }
+  async function sitemap(props) {
+    const id = await props.id;
+    const siteUrl = trimSlash(config.siteUrl);
+    const settings = await resolveSitemapSettings(config, opts);
+    const localize = (entries) => localizeEntries(entries, siteUrl, settings.locales);
+    if (id === "static") return localize(staticEntries(staticRoutes));
+    if (id === "authors") {
+      if (!settings.authors) return [];
+      const authors = await safeFetchAuthors(config);
+      const base = trimSlash(opts.authorBasePath ?? "/blog/author");
+      return localize(
+        authors.map((a) => ({
+          url: `${siteUrl}${base}/${encodeURIComponent(a.slug)}`,
+          lastModified: a.lastUpdatedAt ?? void 0
+        }))
+      );
+    }
+    const collections = await resolveCollections(config.collections);
+    const posts = await safeFetchPosts(config, 200);
+    if (id === "blog") {
+      return localize(postEntries(config, siteUrl, posts, collections, settings));
+    }
+    if (id === "categories") {
+      return localize(categoryEntries(config, siteUrl, posts, collections));
+    }
+    return [];
+  }
+  return { generateSitemaps, sitemap };
+}
 
 // src/routes-llms.ts
 import { isInCollectionMode as isInCollectionMode2, resolvePostUrl as resolvePostUrl3 } from "@roottale/cms-core";
@@ -212,7 +307,17 @@ function createRevalidateRoute(config) {
     if (!result.ok) {
       return Response.json({ ok: false, reason: result.reason }, { status: 401 });
     }
-    const INVARIANTS = ["/feed.xml", "/sitemap.xml", "/llms.txt"];
+    const INVARIANTS = [
+      "/feed.xml",
+      "/llms.txt",
+      "/sitemap.xml",
+      "/sitemap/static.xml",
+      "/sitemap/blog.xml",
+      "/sitemap/categories.xml",
+      // 작가 사이트맵 — 글 발행/해제로 작가 등장·lastmod 가 바뀐다(authors 토글 off 면
+      // 빈 사이트맵이라 무효화해도 무해).
+      "/sitemap/authors.xml"
+    ];
     let alsoRevalidate;
     let warning;
     if (config.alsoRevalidate) {
@@ -453,6 +558,41 @@ function createRedirectMiddleware(config) {
   };
 }
 
+// src/routes-metadata.ts
+import { resolvePostPath } from "@roottale/cms-core";
+function buildPostMetadata(post, options = {}) {
+  const seo = post.seo ?? void 0;
+  const title = seo?.title || post.title;
+  const description = seo?.description || post.description || void 0;
+  const ogImage = seo?.ogImage || post.image || void 0;
+  let canonical = seo?.canonical || void 0;
+  if (!canonical && options.siteUrl) {
+    let path = options.path;
+    if (!path && options.collections && post.slug) {
+      path = resolvePostPath(
+        { slug: post.slug, terms: [], collectionKey: post.collectionKey ?? null },
+        options.collections
+      ) ?? void 0;
+    }
+    if (path) {
+      const normalized = path.startsWith("/") ? path : `/${path}`;
+      canonical = `${trimSlash(options.siteUrl)}${normalized}`;
+    }
+  }
+  const openGraph = { type: "article", title };
+  if (description) openGraph.description = description;
+  if (canonical) openGraph.url = canonical;
+  if (post.date) openGraph.publishedTime = post.date;
+  if (ogImage) openGraph.images = [{ url: ogImage, alt: title }];
+  const meta = { title, openGraph };
+  if (description) meta.description = description;
+  if (canonical) meta.alternates = { canonical };
+  if (seo?.noindex || seo?.nofollow) {
+    meta.robots = { index: !seo.noindex, follow: !seo.nofollow };
+  }
+  return meta;
+}
+
 // src/routes.ts
 function postRedirectPath(post, requestedSlug, blogBasePath = "/blog") {
   let requested = requestedSlug;
@@ -471,7 +611,7 @@ function createFleetInfoRoute(config = {}) {
         site: config.site ?? env.VERCEL_PROJECT_PRODUCTION_URL ?? null,
         framework: "next",
         cms_client: CMS_CLIENT_VERSION,
-        cms_renderer: true ? "0.35.0" : "dev",
+        cms_renderer: true ? "0.37.0" : "dev",
         build_sha: env.VERCEL_GIT_COMMIT_SHA?.slice(0, 7) ?? null
       },
       { headers: { "cache-control": "public, max-age=300" } }
@@ -481,6 +621,7 @@ function createFleetInfoRoute(config = {}) {
 export {
   OG_IMAGE_CONTENT_TYPE,
   OG_IMAGE_SIZE,
+  buildPostMetadata,
   createFeedRoute,
   createFleetInfoRoute,
   createLlmsTxtRoute,
@@ -488,6 +629,7 @@ export {
   createRedirectMiddleware,
   createRevalidateRoute,
   createSitemap,
+  createSitemapIndex,
   matchRedirect,
   normalizeRedirectPath,
   postRedirectPath,