@publish.os/nextjs 0.0.1-alpha.1 → 0.0.1-alpha.3

package/dist/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,31 +15,32 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   PageList: () => PageList,
-  Providers: () => Providers,
+  cleanHeadingText: () => cleanHeadingText,
   cn: () => cn,
+  createAtomFeedRoute: () => createAtomFeedRoute,
+  createHeadingIdGenerator: () => createHeadingIdGenerator,
+  createJsonFeedRoute: () => createJsonFeedRoute,
   createLlmsTxtRoute: () => createLlmsTxtRoute,
   createNextConfig: () => createNextConfig,
+  createOgImageRoute: () => createOgImageRoute,
+  createOgImageStaticParams: () => createOgImageStaticParams,
   createRobotsTxtRoute: () => createRobotsTxtRoute,
+  createRssFeedRoute: () => createRssFeedRoute,
   createSitemapXmlRoute: () => createSitemapXmlRoute,
+  extractMdxHeadings: () => extractMdxHeadings,
+  headingToHTMLId: () => headingToHTMLId,
   listStaticParams: () => listStaticParams,
   resolveGroup: () => resolveGroup,
   resolveGroupLayout: () => resolveGroupLayout,
   resolveLeaf: () => resolveLeaf,
-  tags: () => tags
+  tags: () => tags,
+  urlIdToText: () => urlIdToText
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -91,11 +90,39 @@ var tags = {
   },
   llms(scope = "root") {
     return assertTag(`llms:${safeSegment(scope)}`);
+  },
+  feed(format, scope = "site") {
+    return assertTag(`feed:${safeSegment(format)}:${safeSegment(scope)}`);
   }
 };
 
-// src/components/page-list.tsx
-var import_link = __toESM(require("next/link"), 1);
+// src/config/createNextConfig.ts
+function createNextConfig(_options) {
+  return {
+    transpilePackages: ["@publish.os/nextjs"],
+    cacheComponents: true,
+    cacheLife: {
+      page: {
+        stale: 60 * 60 * 24,
+        revalidate: 60 * 60 * 24 * 30,
+        expire: 60 * 60 * 24 * 365
+      },
+      feed: {
+        stale: 60 * 60,
+        revalidate: 60 * 60 * 6,
+        expire: 60 * 60 * 24 * 7
+      },
+      sitemap: {
+        stale: 60 * 60,
+        revalidate: 60 * 60 * 24,
+        expire: 60 * 60 * 24 * 30
+      }
+    }
+  };
+}
+
+// src/kernel/components/blocks/page-list.tsx
+var import_link = require("../ui/link.js");
 var import_jsx_runtime = require("react/jsx-runtime");
 function pageNodes(nodes) {
   return nodes.flatMap((node) => {
@@ -114,62 +141,927 @@ function PageList({ tree, currentPath, className }) {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("nav", { "aria-label": "Pages in this group", className, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("ul", { className: "space-y-2 text-sm", children: pages.map((page) => {
     const active = page.path === currentPath;
     return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("li", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-      import_link.default,
+      import_link.Link,
       {
-        "aria-current": active ? "page" : void 0,
-        className: active ? "font-medium text-accent-1 underline underline-offset-4" : "text-foreground-2 underline-offset-4 hover:text-accent-1 hover:underline",
+        active,
+        color: active ? "accent" : "default",
         href: page.path,
+        size: "sm",
         children: page.title
       }
-    ) }, `${page.group}:${page.id}`);
+    ) }, `${page.group}:${page.fileID}`);
   }) }) });
 }
 
-// src/components/providers.tsx
-var import_next_themes = require("next-themes");
-var import_jsx_runtime2 = require("react/jsx-runtime");
-function Providers({ children }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-    import_next_themes.ThemeProvider,
+// src/kernel/routes/metadata/feed.ts
+var import_cache = require("next/cache");
+
+// src/kernel/routes/response.ts
+var CACHE_CONTROL = "public, max-age=300, s-maxage=86400, stale-while-revalidate=3600, must-revalidate";
+var CDN_CACHE_CONTROL = "public, max-age=2592000, stale-while-revalidate=31536000";
+var SHORT_CACHE_CONTROL = "public, max-age=60, s-maxage=600, stale-while-revalidate=300, must-revalidate";
+var SHORT_CDN_CACHE_CONTROL = "public, max-age=300, stale-while-revalidate=3600";
+function cacheControl(policy) {
+  if (!policy || policy === "default") return CACHE_CONTROL;
+  if (policy === "short") return SHORT_CACHE_CONTROL;
+  return policy;
+}
+function cdnCacheControl(policy) {
+  if (!policy || policy === "default") return CDN_CACHE_CONTROL;
+  if (policy === "short") return SHORT_CDN_CACHE_CONTROL;
+  return policy;
+}
+function cachedTextHeaders(contentType, options = {}) {
+  const headers = new Headers(options.headers);
+  headers.set("cache-control", cacheControl(options.cachePolicy));
+  headers.set("cdn-cache-control", cdnCacheControl(options.cachePolicy));
+  headers.set("vercel-cdn-cache-control", cdnCacheControl(options.cachePolicy));
+  headers.set("content-type", contentType);
+  headers.set("x-content-type-options", "nosniff");
+  if (options.etag) headers.set("etag", options.etag);
+  if (options.noindex) headers.set("x-robots-tag", "noindex");
+  return headers;
+}
+function createCachedTextResponse(options) {
+  const status = options.status ?? 200;
+  const method = options.method ?? options.request?.method ?? "GET";
+  const headers = cachedTextHeaders(options.contentType, options);
+  const isNotModified = status === 200 && options.etag && options.request?.headers.get("if-none-match") === options.etag;
+  return new Response(
+    method === "HEAD" || isNotModified ? null : options.body,
     {
-      attribute: "class",
-      defaultTheme: "system",
-      disableTransitionOnChange: true,
-      enableSystem: true,
-      children
+      headers,
+      status: isNotModified ? 304 : status
     }
   );
 }
 
-// src/config/createNextConfig.ts
-function createNextConfig(_options) {
+// src/kernel/routes/metadata/feed.ts
+function xmlEscape(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function pageTimestamp(page) {
+  const value = page.publishedAt ?? page.updatedAt;
+  if (!value) return -Infinity;
+  const timestamp = Date.parse(value);
+  return Number.isNaN(timestamp) ? -Infinity : timestamp;
+}
+function canonicalUrl(manifest, path) {
+  const origin = manifest.site.url?.replace(/\/+$/, "");
+  if (!origin) return path;
+  try {
+    return new URL(path, `${origin}/`).toString();
+  } catch {
+    return path;
+  }
+}
+function pageInScope(page, options) {
+  if (options.scope === "site" || !options.group) return true;
+  if (options.scope === "self") return page.group === options.group;
+  return page.group === options.group || page.group.startsWith(`${options.group}/`);
+}
+function feedPages(manifest, options) {
+  const statuses = options.status ?? ["published"];
+  const pages = manifest.pages.filter((page) => statuses.includes(page.status)).filter((page) => pageInScope(page, options)).sort((a, b) => pageTimestamp(b) - pageTimestamp(a));
+  return options.limit ? pages.slice(0, options.limit) : pages;
+}
+async function rssXml(manifest, options = {}) {
+  "use cache";
+  (0, import_cache.cacheLife)("page");
+  (0, import_cache.cacheTag)(
+    tags.site(),
+    tags.feed("rss", options.group ?? options.scope ?? "site"),
+    tags.manifest(manifest.contentHash)
+  );
+  const title = manifest.site.name;
+  const description = manifest.site.description ?? title;
+  const pages = feedPages(manifest, options);
+  const homeUrl = canonicalUrl(manifest, "/");
+  const items = pages.map((page) => {
+    const pageUrl = canonicalUrl(manifest, page.path);
+    const pubDate = page.publishedAt ? `
+      <pubDate>${xmlEscape(new Date(page.publishedAt).toUTCString())}</pubDate>` : "";
+    const description2 = page.description ? `
+      <description>${xmlEscape(page.description)}</description>` : "";
+    return `    <item>
+      <title>${xmlEscape(page.title)}</title>
+      <link>${xmlEscape(pageUrl)}</link>
+      <guid>${xmlEscape(pageUrl)}</guid>${pubDate}${description2}
+    </item>`;
+  }).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+  <channel>
+    <title>${xmlEscape(title)}</title>
+    <link>${xmlEscape(homeUrl)}</link>
+    <description>${xmlEscape(description)}</description>
+${items}
+  </channel>
+</rss>
+`;
+}
+function pageDate(page) {
+  return page.publishedAt ?? page.updatedAt;
+}
+function latestFeedDate(pages) {
+  const timestamp = Math.max(0, ...pages.map((page) => pageTimestamp(page)));
+  return new Date(timestamp).toISOString();
+}
+async function atomXml(manifest, options = {}) {
+  "use cache";
+  (0, import_cache.cacheLife)("page");
+  (0, import_cache.cacheTag)(
+    tags.site(),
+    tags.feed("atom", options.group ?? options.scope ?? "site"),
+    tags.manifest(manifest.contentHash)
+  );
+  const title = manifest.site.name;
+  const pages = feedPages(manifest, options);
+  const homeUrl = canonicalUrl(manifest, "/");
+  const entries = pages.map((page) => {
+    const date = pageDate(page);
+    const updated = date ? new Date(date).toISOString() : latestFeedDate([]);
+    const pageUrl = canonicalUrl(manifest, page.path);
+    const summary = page.description ? `
+    <summary>${xmlEscape(page.description)}</summary>` : "";
+    return `  <entry>
+    <title>${xmlEscape(page.title)}</title>
+    <id>${xmlEscape(pageUrl)}</id>
+    <link href="${xmlEscape(pageUrl)}" />
+    <updated>${xmlEscape(updated)}</updated>${summary}
+  </entry>`;
+  }).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title>${xmlEscape(title)}</title>
+  <id>${xmlEscape(homeUrl)}</id>
+  <updated>${xmlEscape(latestFeedDate(pages))}</updated>
+${entries}
+</feed>
+`;
+}
+async function jsonFeed(manifest, options = {}) {
+  "use cache";
+  (0, import_cache.cacheLife)("page");
+  (0, import_cache.cacheTag)(
+    tags.site(),
+    tags.feed("json", options.group ?? options.scope ?? "site"),
+    tags.manifest(manifest.contentHash)
+  );
+  const pages = feedPages(manifest, options);
+  return `${JSON.stringify(
+    {
+      version: "https://jsonfeed.org/version/1.1",
+      title: manifest.site.name,
+      description: manifest.site.description,
+      home_page_url: canonicalUrl(manifest, "/"),
+      items: pages.map((page) => ({
+        id: canonicalUrl(manifest, page.path),
+        url: canonicalUrl(manifest, page.path),
+        title: page.title,
+        summary: page.description,
+        content_text: page.body,
+        date_published: page.publishedAt,
+        date_modified: page.updatedAt,
+        tags: page.tags
+      }))
+    },
+    null,
+    2
+  )}
+`;
+}
+function createRssFeedRoute(manifest, options = {}) {
+  return async function GET() {
+    return createCachedTextResponse({
+      body: await rssXml(manifest, options),
+      contentType: "application/rss+xml; charset=utf-8"
+    });
+  };
+}
+function createAtomFeedRoute(manifest, options = {}) {
+  return async function GET() {
+    return createCachedTextResponse({
+      body: await atomXml(manifest, options),
+      contentType: "application/atom+xml; charset=utf-8"
+    });
+  };
+}
+function createJsonFeedRoute(manifest, options = {}) {
+  return async function GET() {
+    return createCachedTextResponse({
+      body: await jsonFeed(manifest, options),
+      contentType: "application/feed+json; charset=utf-8"
+    });
+  };
+}
+
+// src/kernel/routes/metadata/llms.ts
+var import_cache2 = require("next/cache");
+var TEXT_ENCODER = new TextEncoder();
+function pageInScope2(page, options) {
+  if (options.scope === "site" || !options.group) return true;
+  if (options.scope === "self") return page.group === options.group;
+  return page.group === options.group || page.group.startsWith(`${options.group}/`);
+}
+function llmsSummary(manifest) {
+  return manifest.site.description ? `> ${manifest.site.description}` : `> Agent-readable index for ${manifest.site.name}.`;
+}
+async function llmsTxt(manifest, options = {}) {
+  "use cache";
+  (0, import_cache2.cacheLife)("page");
+  (0, import_cache2.cacheTag)(
+    tags.site(),
+    tags.llms(options.group ?? options.scope ?? "root"),
+    tags.manifest(manifest.contentHash)
+  );
+  const pages = manifest.pages.filter((page) => page.status === "published").filter((page) => pageInScope2(page, options));
+  const visiblePages = options.limit ? pages.slice(0, options.limit) : pages;
+  const lines = visiblePages.map((page) => {
+    const description = options.includeDescriptions && page.description ? ` - ${page.description}` : "";
+    return `- [${page.title}](${page.path})${description}`;
+  });
+  const linkLines = (options.links ?? []).map(
+    (link) => `- [${link.title}](${link.path})`
+  );
+  const linkSection = linkLines.length ? `
+
+## Group LLM indexes
+
+${linkLines.join("\n")}` : "";
+  return `# ${manifest.site.name}
+
+${llmsSummary(manifest)}
+
+${lines.join("\n")}${linkSection}
+`;
+}
+function createLlmsTxtRoute(manifest, options = {}) {
+  return async function GET() {
+    return createCachedTextResponse({
+      body: await llmsTxt(manifest, options),
+      contentType: "text/plain; charset=utf-8"
+    });
+  };
+}
+
+// src/kernel/routes/metadata/og-image.tsx
+var import_promises = require("fs/promises");
+var import_node_module = require("module");
+var import_og = require("next/og");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var ERROR_HEADERS = {
+  "cache-control": "public, max-age=60, must-revalidate",
+  "cdn-cache-control": "public, max-age=300",
+  "vercel-cdn-cache-control": "public, max-age=300",
+  "x-content-type-options": "nosniff"
+};
+var SUCCESS_HEADERS = {
+  "cache-control": "public, max-age=31536000, immutable",
+  "cdn-cache-control": "public, max-age=31536000, immutable",
+  "vercel-cdn-cache-control": "public, max-age=31536000, immutable",
+  "x-content-type-options": "nosniff"
+};
+var DEVELOPMENT_SUCCESS_HEADERS = {
+  "cache-control": "no-store",
+  "cdn-cache-control": "no-store",
+  "vercel-cdn-cache-control": "no-store",
+  "x-content-type-options": "nosniff"
+};
+var KEY_PATTERN = /^[a-f0-9]{16}$/;
+var DESCRIPTION_MAX_LENGTH = 260;
+var LABEL_MAX_LENGTH = 72;
+var SITE_NAME_MAX_LENGTH = 42;
+var TITLE_MAX_LENGTH = 220;
+var GRID_INSET = 86;
+var GRID_BOTTOM = 544;
+var CONTENT_X = 122;
+var CONTENT_WIDTH = 956;
+var TITLE_MAX_FONT_SIZE = 60;
+var TITLE_MIN_FONT_SIZE = 40;
+var LOGO_MAX_WIDTH = 300;
+var LOGO_MAX_HEIGHT = 46;
+var MAX_RESPONSE_CACHE_ENTRIES = 128;
+var BADGE_RADIUS = 999;
+var CONTENT_TYPE_HEADER = { "content-type": "image/png" };
+var PLATFORM_FONT_FAMILY = "PublishOS Geist";
+var PLATFORM_FONT_WEIGHTS = [
+  400,
+  500,
+  600,
+  700,
+  800
+];
+var fontArrayBufferCache = /* @__PURE__ */ new Map();
+var imageResponseFontCache = /* @__PURE__ */ new Map();
+var imageResponseCache = /* @__PURE__ */ new Map();
+var require2 = (0, import_node_module.createRequire)(`${process.cwd()}/package.json`);
+var platformFontPath = require2.resolve(
+  "next/dist/compiled/@vercel/og/Geist-Regular.ttf"
+);
+var platformFontData;
+function isDevelopment() {
+  return process.env.NODE_ENV === "development";
+}
+function successHeaders() {
+  return isDevelopment() ? DEVELOPMENT_SUCCESS_HEADERS : SUCCESS_HEADERS;
+}
+function clampText(value, maxLength) {
+  if (!value) return void 0;
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, maxLength - 3).trimEnd()}...`;
+}
+async function routeKey(context) {
+  const params = await context.params;
+  return params.key.replace(/\.png$/, "");
+}
+function ellipsize(value, maxLength) {
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, maxLength - 3).trimEnd()}...`;
+}
+function wrapText(options) {
+  const source = clampText(options.text, options.maxLength);
+  if (!source) return [];
+  const maxCharsPerLine = Math.max(
+    12,
+    Math.floor(options.width / (options.fontSize * 0.54))
+  );
+  const words = source.split(/\s+/).filter(Boolean);
+  const lines = [];
+  let line = "";
+  for (const word of words) {
+    const nextLine = line ? `${line} ${word}` : word;
+    if (nextLine.length <= maxCharsPerLine) {
+      line = nextLine;
+      continue;
+    }
+    if (line) lines.push(line);
+    line = word.length > maxCharsPerLine ? ellipsize(word, maxCharsPerLine) : word;
+    if (lines.length === options.maxLines) break;
+  }
+  if (line && lines.length < options.maxLines) lines.push(line);
+  const consumed = lines.join(" ").replace(/\.\.\.$/, "");
+  const didOverflow = words.join(" ").length > consumed.length || (lines.at(-1)?.endsWith("...") ?? false);
+  if (didOverflow && lines.length > 0) {
+    const lastIndex = lines.length - 1;
+    lines[lastIndex] = ellipsize(lines[lastIndex] ?? "", maxCharsPerLine);
+  }
+  return lines;
+}
+function singleLineText(options) {
+  const source = clampText(options.text, options.maxLength);
+  if (!source) return void 0;
+  const charWidth = options.fontSize * (options.mono ? 0.62 : 0.54);
+  const maxChars = Math.max(4, Math.floor(options.width / charWidth));
+  return ellipsize(source.replace(/\s+/g, " "), maxChars);
+}
+function titleFontSize(title) {
+  const length = title?.length ?? 0;
+  if (length > 130) return TITLE_MIN_FONT_SIZE;
+  if (length > 100) return 44;
+  if (length > 80) return 48;
+  if (length > 60) return 52;
+  if (length > 40) return 56;
+  return TITLE_MAX_FONT_SIZE;
+}
+function siteUrl(value) {
+  if (!value) return void 0;
+  const candidate = value.includes("://") ? value : `https://${value}`;
+  try {
+    return new URL(candidate);
+  } catch {
+    return void 0;
+  }
+}
+function displayUrlParts(entry) {
+  const url = siteUrl(entry.siteUrl);
+  const host = url?.hostname ?? entry.siteUrl?.replace(/\/.*$/, "") ?? "";
+  const basePath = url?.pathname.replace(/\/+$/, "") ?? "";
+  const routePath = entry.routePath === "/" ? "" : `/${entry.routePath.replace(/^\/+/, "")}`;
+  const path = `${basePath === "/" ? "" : basePath}${routePath}`;
+  if (host) return { host, path };
+  return { host: "", path: path || routePath };
+}
+function dataUrlToArrayBuffer(value) {
+  const cached = fontArrayBufferCache.get(value);
+  if (cached) return cached;
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  fontArrayBufferCache.set(value, bytes.buffer);
+  return bytes.buffer;
+}
+function platformFonts() {
+  platformFontData ??= (0, import_promises.readFile)(platformFontPath).then(
+    (data) => data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength)
+  );
+  return platformFontData.then(
+    (data) => PLATFORM_FONT_WEIGHTS.map((weight) => ({
+      data: data.slice(0),
+      name: PLATFORM_FONT_FAMILY,
+      style: "normal",
+      weight
+    }))
+  );
+}
+async function imageResponseFonts(entry) {
+  const cached = imageResponseFontCache.get(entry.key);
+  if (cached) return cached;
+  const manifestFonts = ["main", "mono"].flatMap((role) => {
+    const font = entry.fonts?.[role];
+    return font?.files?.map((file) => ({
+      data: dataUrlToArrayBuffer(file.data),
+      name: font.family,
+      style: file.style,
+      weight: file.weight
+    })) ?? [];
+  });
+  const fonts = manifestFonts.length > 0 ? [...manifestFonts, ...await platformFonts()] : await platformFonts();
+  imageResponseFontCache.set(entry.key, fonts);
+  return fonts;
+}
+function fontFamily(font, fallback) {
+  const fallbackStack = fallback === "mono" ? `"${PLATFORM_FONT_FAMILY}", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace` : `"${PLATFORM_FONT_FAMILY}", Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif`;
+  return font?.family ? `${JSON.stringify(font.family)}, ${fallbackStack}` : fallbackStack;
+}
+function fittedLogoDimensions(logo) {
+  if (!logo?.width || !logo.height) return void 0;
+  const scale = Math.min(
+    LOGO_MAX_WIDTH / logo.width,
+    LOGO_MAX_HEIGHT / logo.height,
+    1
+  );
   return {
-    transpilePackages: ["@publish.os/nextjs"],
-    cacheComponents: true,
-    cacheLife: {
-      page: {
-        stale: 60 * 60 * 24,
-        revalidate: 60 * 60 * 24 * 30,
-        expire: 60 * 60 * 24 * 365
-      },
-      feed: {
-        stale: 60 * 60,
-        revalidate: 60 * 60 * 6,
-        expire: 60 * 60 * 24 * 7
-      },
-      sitemap: {
-        stale: 60 * 60,
-        revalidate: 60 * 60 * 24,
-        expire: 60 * 60 * 24 * 30
-      }
+    height: Math.max(1, Math.round(logo.height * scale)),
+    width: Math.max(1, Math.round(logo.width * scale))
+  };
+}
+function cacheImageResponse(key, render) {
+  if (isDevelopment()) return render();
+  const cached = imageResponseCache.get(key);
+  if (cached) return cached;
+  const promise = render().catch((error) => {
+    imageResponseCache.delete(key);
+    throw error;
+  });
+  imageResponseCache.set(key, promise);
+  if (imageResponseCache.size > MAX_RESPONSE_CACHE_ENTRIES) {
+    const oldest = imageResponseCache.keys().next().value;
+    if (oldest) imageResponseCache.delete(oldest);
+  }
+  return promise;
+}
+function responseFromCachedImage(cached) {
+  return new Response(cached.body.slice(0), {
+    headers: cached.headers,
+    status: cached.status
+  });
+}
+async function cachedImageResponse(response) {
+  const headersToApply = successHeaders();
+  const headers = new Headers(response.headers);
+  headers.set("cache-control", headersToApply["cache-control"]);
+  headers.set("cdn-cache-control", headersToApply["cdn-cache-control"]);
+  headers.set(
+    "vercel-cdn-cache-control",
+    headersToApply["vercel-cdn-cache-control"]
+  );
+  headers.set(
+    "x-content-type-options",
+    headersToApply["x-content-type-options"]
+  );
+  if (!headers.has("content-type")) {
+    headers.set("content-type", CONTENT_TYPE_HEADER["content-type"]);
+  }
+  return {
+    body: await response.arrayBuffer(),
+    headers,
+    status: response.status
+  };
+}
+function createOgImageRoute({ manifest }) {
+  return async function GET(_request, context) {
+    const key = await routeKey(context);
+    if (!KEY_PATTERN.test(key)) {
+      return new Response("Bad request", {
+        headers: ERROR_HEADERS,
+        status: 400
+      });
     }
+    const entry = manifest.generated[key];
+    if (!entry || entry.source !== "generated") {
+      return new Response("Not found", {
+        headers: ERROR_HEADERS,
+        status: 404
+      });
+    }
+    const titleSize = titleFontSize(entry.title);
+    const titleLines = wrapText({
+      fontSize: titleSize,
+      maxLength: TITLE_MAX_LENGTH,
+      maxLines: 2,
+      text: entry.title,
+      width: 900
+    });
+    const descriptionLines = wrapText({
+      fontSize: 30,
+      maxLength: DESCRIPTION_MAX_LENGTH,
+      maxLines: 2,
+      text: entry.description,
+      width: 870
+    });
+    const label = singleLineText({
+      fontSize: 22,
+      maxLength: LABEL_MAX_LENGTH,
+      mono: true,
+      text: entry.label,
+      width: 520
+    });
+    const displayUrl = displayUrlParts(entry);
+    const siteName = clampText(
+      entry.siteName ?? entry.alt,
+      SITE_NAME_MAX_LENGTH
+    );
+    const background = entry.background ?? "#ffffff";
+    const textPrimary = entry.textPrimary ?? "#111111";
+    const textSecondary = entry.textSecondary ?? "#525252";
+    const accent = entry.accent ?? "#2563eb";
+    const stroke = entry.stroke ?? "#e5e7eb";
+    const logoSrc = entry.logo?.dataUri;
+    const logoDimensions = fittedLogoDimensions(entry.logo);
+    return responseFromCachedImage(
+      await cacheImageResponse(
+        entry.key,
+        async () => cachedImageResponse(
+          new import_og.ImageResponse(
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+              "div",
+              {
+                style: {
+                  background,
+                  color: textPrimary,
+                  display: "flex",
+                  fontFamily: fontFamily(entry.fonts?.main, "sans"),
+                  height: "100%",
+                  position: "relative",
+                  width: "100%"
+                },
+                children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                    "div",
+                    {
+                      style: {
+                        background: stroke,
+                        display: "flex",
+                        height: "100%",
+                        left: GRID_INSET,
+                        position: "absolute",
+                        top: 0,
+                        width: 2
+                      }
+                    }
+                  ),
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                    "div",
+                    {
+                      style: {
+                        background: stroke,
+                        display: "flex",
+                        height: "100%",
+                        position: "absolute",
+                        right: GRID_INSET,
+                        top: 0,
+                        width: 2
+                      }
+                    }
+                  ),
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                    "div",
+                    {
+                      style: {
+                        background: stroke,
+                        display: "flex",
+                        height: 2,
+                        left: 0,
+                        position: "absolute",
+                        top: GRID_INSET,
+                        width: "100%"
+                      }
+                    }
+                  ),
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                    "div",
+                    {
+                      style: {
+                        background: stroke,
+                        bottom: GRID_INSET,
+                        display: "flex",
+                        height: 2,
+                        left: 0,
+                        position: "absolute",
+                        width: "100%"
+                      }
+                    }
+                  ),
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                    "div",
+                    {
+                      style: {
+                        alignItems: "center",
+                        color: accent,
+                        display: "flex",
+                        fontFamily: fontFamily(entry.fonts?.main, "sans"),
+                        fontSize: 22,
+                        fontWeight: 700,
+                        height: GRID_INSET,
+                        justifyContent: "flex-start",
+                        left: CONTENT_X,
+                        lineHeight: 1,
+                        overflow: "hidden",
+                        position: "absolute",
+                        top: 0,
+                        width: 430
+                      },
+                      children: logoSrc ? (
+                        // biome-ignore lint/performance/noImgElement: ImageResponse renders static manifest-provided logo data; next/image is not available in Satori output.
+                        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                          "img",
+                          {
+                            alt: "",
+                            src: logoSrc,
+                            style: {
+                              height: logoDimensions?.height ?? LOGO_MAX_HEIGHT,
+                              maxHeight: LOGO_MAX_HEIGHT,
+                              maxWidth: LOGO_MAX_WIDTH,
+                              objectFit: "contain",
+                              objectPosition: "left center",
+                              width: logoDimensions?.width ?? "auto"
+                            }
+                          }
+                        )
+                      ) : siteName
+                    }
+                  ),
+                  label ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                    "div",
+                    {
+                      style: {
+                        alignItems: "center",
+                        display: "flex",
+                        fontFamily: fontFamily(entry.fonts?.mono, "mono"),
+                        height: GRID_INSET,
+                        justifyContent: "flex-end",
+                        overflow: "hidden",
+                        position: "absolute",
+                        right: CONTENT_X,
+                        top: 0,
+                        width: 520
+                      },
+                      children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+                        "div",
+                        {
+                          style: {
+                            alignItems: "center",
+                            borderRadius: BADGE_RADIUS,
+                            color: accent,
+                            display: "flex",
+                            fontSize: 20,
+                            fontWeight: 600,
+                            lineHeight: 1,
+                            maxWidth: 520,
+                            overflow: "hidden",
+                            paddingBottom: 6,
+                            paddingLeft: 12,
+                            paddingRight: 12,
+                            paddingTop: 6,
+                            position: "relative"
+                          },
+                          children: [
+                            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                              "div",
+                              {
+                                style: {
+                                  background: accent,
+                                  borderRadius: BADGE_RADIUS,
+                                  bottom: 0,
+                                  display: "flex",
+                                  left: 0,
+                                  opacity: 0.14,
+                                  position: "absolute",
+                                  right: 0,
+                                  top: 0
+                                }
+                              }
+                            ),
+                            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                              "div",
+                              {
+                                style: {
+                                  borderColor: accent,
+                                  borderRadius: BADGE_RADIUS,
+                                  borderStyle: "solid",
+                                  borderWidth: 1,
+                                  bottom: 0,
+                                  display: "flex",
+                                  left: 0,
+                                  opacity: 0.32,
+                                  position: "absolute",
+                                  right: 0,
+                                  top: 0
+                                }
+                              }
+                            ),
+                            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { display: "flex", position: "relative" }, children: label })
+                          ]
+                        }
+                      )
+                    }
+                  ) : null,
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+                    "div",
+                    {
+                      style: {
+                        display: "flex",
+                        flexDirection: "column",
+                        gap: 24,
+                        left: CONTENT_X,
+                        position: "absolute",
+                        top: 164,
+                        width: CONTENT_WIDTH
+                      },
+                      children: [
+                        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                          "div",
+                          {
+                            style: {
+                              display: "flex",
+                              flexDirection: "column",
+                              fontSize: titleSize,
+                              fontWeight: 800,
+                              letterSpacing: 0,
+                              lineHeight: 1.08,
+                              width: 900
+                            },
+                            children: titleLines.map((line) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { display: "flex" }, children: line }, line))
+                          }
+                        ),
+                        descriptionLines.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                          "div",
+                          {
+                            style: {
+                              color: textSecondary,
+                              display: "flex",
+                              flexDirection: "column",
+                              fontSize: 30,
+                              lineHeight: 1.25,
+                              width: 870
+                            },
+                            children: descriptionLines.map((line) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { display: "flex" }, children: line }, line))
+                          }
+                        ) : null
+                      ]
+                    }
+                  ),
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                    "div",
+                    {
+                      style: {
+                        alignItems: "center",
+                        display: "flex",
+                        fontFamily: fontFamily(entry.fonts?.mono, "mono"),
+                        fontSize: 22,
+                        height: GRID_INSET,
+                        justifyContent: "flex-start",
+                        left: CONTENT_X,
+                        lineHeight: 1.2,
+                        overflow: "hidden",
+                        position: "absolute",
+                        top: GRID_BOTTOM,
+                        width: CONTENT_WIDTH
+                      },
+                      children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+                        "div",
+                        {
+                          style: {
+                            display: "flex",
+                            flexDirection: "row",
+                            overflow: "hidden",
+                            textOverflow: "ellipsis",
+                            whiteSpace: "nowrap",
+                            width: CONTENT_WIDTH
+                          },
+                          children: [
+                            displayUrl.host ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                              "div",
+                              {
+                                style: {
+                                  color: textSecondary,
+                                  display: "flex",
+                                  flexShrink: 0,
+                                  whiteSpace: "nowrap"
+                                },
+                                children: displayUrl.host
+                              }
+                            ) : null,
+                            displayUrl.path ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                              "div",
+                              {
+                                style: {
+                                  color: textPrimary,
+                                  display: "flex",
+                                  minWidth: 0,
+                                  overflow: "hidden",
+                                  textOverflow: "ellipsis",
+                                  whiteSpace: "nowrap"
+                                },
+                                children: displayUrl.path
+                              }
+                            ) : null
+                          ]
+                        }
+                      )
+                    }
+                  )
+                ]
+              }
+            ),
+            {
+              fonts: await imageResponseFonts(entry),
+              headers: {
+                ...CONTENT_TYPE_HEADER,
+                ...successHeaders()
+              },
+              height: manifest.height,
+              width: manifest.width
+            }
+          )
+        )
+      )
+    );
+  };
+}
+function createOgImageStaticParams({ manifest }) {
+  return Object.keys(manifest.generated).map((key) => ({ key: `${key}.png` }));
+}
+
+// src/kernel/routes/metadata/robots.ts
+var import_cache3 = require("next/cache");
+async function robotsTxt(manifest) {
+  "use cache";
+  (0, import_cache3.cacheLife)("page");
+  (0, import_cache3.cacheTag)(tags.site(), tags.robots(), tags.manifest(manifest.contentHash));
+  return "User-agent: *\nAllow: /\nSitemap: /sitemap.xml\n";
+}
+function createRobotsTxtRoute(manifest) {
+  return async function GET() {
+    return createCachedTextResponse({
+      body: await robotsTxt(manifest),
+      contentType: "text/plain; charset=utf-8"
+    });
+  };
+}
+
+// src/kernel/routes/metadata/sitemap.ts
+var import_cache4 = require("next/cache");
+function xmlEscape2(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+async function sitemapXml(manifest) {
+  "use cache";
+  (0, import_cache4.cacheLife)("page");
+  (0, import_cache4.cacheTag)(tags.site(), tags.sitemap(), tags.manifest(manifest.contentHash));
+  const urls = [
+    "/",
+    ...Object.values(manifest.groups).map((g) => g.path),
+    ...manifest.pages.filter((page) => page.status === "published").map((page) => page.path)
+  ];
+  const uniqueUrls = [...new Set(urls)];
+  const body = uniqueUrls.map((url) => `  <url><loc>${xmlEscape2(url)}</loc></url>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${body}
+</urlset>
+`;
+}
+function createSitemapXmlRoute(manifest) {
+  return async function GET() {
+    return createCachedTextResponse({
+      body: await sitemapXml(manifest),
+      contentType: "application/xml; charset=utf-8"
+    });
   };
 }
 
 // src/resolvers/manifest-resolver.ts
 function findNodeInTree(nodes, id) {
   for (const node of nodes) {
-    if (node.id === id) return node;
+    if (node.type === "page") {
+      if (node.fileID === id) return node;
+    } else if (node.id === id) {
+      return node;
+    }
     if (node.type === "section" || node.type === "folder") {
       const found = findNodeInTree(node.children, id);
       if (found) return found;
@@ -180,7 +1072,7 @@ function findNodeInTree(nodes, id) {
 function pageNode(page) {
   return {
     type: "page",
-    id: page.id,
+    fileID: page.fileID,
     title: page.title,
     path: page.path,
     group: page.group,
@@ -212,7 +1104,7 @@ function resolveLeaf(manifest, group, slug) {
   return {
     site: manifest.site,
     tree: groupData.tree,
-    node: findNodeInTree(groupData.tree, page.id) ?? pageNode(page),
+    node: findNodeInTree(groupData.tree, page.fileID) ?? pageNode(page),
     page,
     currentPath: page.path,
     group
@@ -240,75 +1132,6 @@ function listStaticParams(manifest, group) {
   return groupData.pages.map((page) => ({ slug: page.slug.split("/") }));
 }
 
-// src/routes/llms.ts
-var import_cache = require("next/cache");
-async function llmsTxt(manifest, scope = "root") {
-  "use cache";
-  (0, import_cache.cacheLife)("page");
-  (0, import_cache.cacheTag)(tags.site(), tags.llms(scope), tags.manifest(manifest.contentHash));
-  const pages = manifest.pages.filter(
-    (page) => page.status === "published" && (scope === "root" || page.group === scope)
-  );
-  const lines = pages.map((page) => `- [${page.title}](${page.path})`);
-  return `# ${manifest.site.title}
-
-${lines.join("\n")}
-`;
-}
-function createLlmsTxtRoute(manifest, options = {}) {
-  return async function GET() {
-    return new Response(await llmsTxt(manifest, options.scope), {
-      headers: { "content-type": "text/plain; charset=utf-8" }
-    });
-  };
-}
-
-// src/routes/robots.ts
-var import_cache2 = require("next/cache");
-async function robotsTxt(manifest) {
-  "use cache";
-  (0, import_cache2.cacheLife)("page");
-  (0, import_cache2.cacheTag)(tags.site(), tags.robots(), tags.manifest(manifest.contentHash));
-  return "User-agent: *\nAllow: /\nSitemap: /sitemap.xml\n";
-}
-function createRobotsTxtRoute(manifest) {
-  return async function GET() {
-    return new Response(await robotsTxt(manifest), {
-      headers: { "content-type": "text/plain; charset=utf-8" }
-    });
-  };
-}
-
-// src/routes/sitemap.ts
-var import_cache3 = require("next/cache");
-function xmlEscape(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-async function sitemapXml(manifest) {
-  "use cache";
-  (0, import_cache3.cacheLife)("page");
-  (0, import_cache3.cacheTag)(tags.site(), tags.sitemap(), tags.manifest(manifest.contentHash));
-  const urls = [
-    "/",
-    ...Object.values(manifest.groups).map((g) => g.path),
-    ...manifest.pages.filter((page) => page.status === "published").map((page) => page.path)
-  ];
-  const uniqueUrls = [...new Set(urls)];
-  const body = uniqueUrls.map((url) => `  <url><loc>${xmlEscape(url)}</loc></url>`).join("\n");
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${body}
-</urlset>
-`;
-}
-function createSitemapXmlRoute(manifest) {
-  return async function GET() {
-    return new Response(await sitemapXml(manifest), {
-      headers: { "content-type": "application/xml; charset=utf-8" }
-    });
-  };
-}
-
 // src/utils/cn.ts
 var import_clsx = require("clsx");
 var import_tailwind_merge = require("tailwind-merge");
@@ -330,18 +1153,111 @@ var twMerge = (0, import_tailwind_merge.extendTailwindMerge)({
 function cn(...inputs) {
   return twMerge((0, import_clsx.clsx)(inputs));
 }
+
+// src/utils/heading-ids.ts
+var import_react = require("react");
+var SELF_CLOSING_TAG_RE = new RegExp("<[^>]+/>", "g");
+var PAIRED_TAG_RE = /<\/?\w[^>]*>/g;
+var MDX_BOLD_RE = /\*\*(.*?)\*\*/g;
+var MDX_ITALIC_RE = /\*(.*?)\*/g;
+var MDX_UNDERLINE_BOLD_RE = /__(.*?)__/g;
+var MDX_UNDERLINE_ITALIC_RE = /_(.*?)_/g;
+var MDX_STRIKETHROUGH_RE = /~~(.*?)~~/g;
+var MDX_INLINE_CODE_RE = /`(.*?)`/g;
+var MDX_LINK_RE = /\[(.*?)\]\(.*?\)/g;
+var NON_ALPHANUMERIC_RE = /[^a-z0-9]+/g;
+var LEADING_TRAILING_HYPHEN_RE = /^-+|-+$/g;
+var LEADING_DIGIT_RE = /^(\d)/;
+var HEADING_RE = /^(#{1,6})[ \t]+(.+?)\s*#*\s*$/gm;
+var FENCED_CODE_RE = /```[\s\S]*?```|~~~[\s\S]*?~~~/g;
+function extractText(node) {
+  if (typeof node === "string") return node;
+  if (typeof node === "number") return String(node);
+  if (node == null || typeof node === "boolean") return "";
+  if (Array.isArray(node)) {
+    return node.map(extractText).join("");
+  }
+  if ((0, import_react.isValidElement)(node)) {
+    const element = node;
+    return element.props.children === void 0 ? "" : extractText(element.props.children);
+  }
+  return "";
+}
+function cleanHeadingText(input) {
+  const text = typeof input === "string" ? input : extractText(input);
+  return text.replace(SELF_CLOSING_TAG_RE, "").replace(PAIRED_TAG_RE, "").replace(MDX_BOLD_RE, "$1").replace(MDX_ITALIC_RE, "$1").replace(MDX_UNDERLINE_BOLD_RE, "$1").replace(MDX_UNDERLINE_ITALIC_RE, "$1").replace(MDX_STRIKETHROUGH_RE, "$1").replace(MDX_INLINE_CODE_RE, "$1").replace(MDX_LINK_RE, "$1").trim();
+}
+function slugify(text) {
+  return text.toLowerCase().replace(NON_ALPHANUMERIC_RE, "-").replace(LEADING_TRAILING_HYPHEN_RE, "").replace(LEADING_DIGIT_RE, "id-$1");
+}
+function headingToHTMLId(input) {
+  try {
+    const id = slugify(cleanHeadingText(input));
+    return id || "empty-heading";
+  } catch {
+    return "empty-heading";
+  }
+}
+function createHeadingIdGenerator() {
+  const usedIds = /* @__PURE__ */ new Map();
+  return (input) => {
+    const baseId = headingToHTMLId(input);
+    if (baseId === "empty-heading") return baseId;
+    const count = usedIds.get(baseId) ?? 0;
+    usedIds.set(baseId, count + 1);
+    return count === 0 ? baseId : `${baseId}-${count}`;
+  };
+}
+function extractMdxHeadings(content = "", levels) {
+  const [minDepth, maxDepth] = levels;
+  const headingId = createHeadingIdGenerator();
+  const headings = [];
+  const searchableContent = content.replace(FENCED_CODE_RE, "");
+  HEADING_RE.lastIndex = 0;
+  while (true) {
+    const match = HEADING_RE.exec(searchableContent);
+    if (!match) break;
+    const marker = match[1];
+    const rawText = match[2];
+    if (!marker || !rawText) continue;
+    const level = marker.length;
+    const text = cleanHeadingText(rawText);
+    const id = headingId(rawText);
+    if (!text || id === "empty-heading") continue;
+    if (level < minDepth || level > maxDepth) continue;
+    headings.push({ id, level, text });
+  }
+  return headings;
+}
+function urlIdToText(urlId) {
+  try {
+    if (typeof urlId !== "string") return "";
+    return urlId.replace(/^id-/, "").replace(/-/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+  } catch {
+    return "";
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PageList,
-  Providers,
+  cleanHeadingText,
   cn,
+  createAtomFeedRoute,
+  createHeadingIdGenerator,
+  createJsonFeedRoute,
   createLlmsTxtRoute,
   createNextConfig,
+  createOgImageRoute,
+  createOgImageStaticParams,
   createRobotsTxtRoute,
+  createRssFeedRoute,
   createSitemapXmlRoute,
+  extractMdxHeadings,
+  headingToHTMLId,
   listStaticParams,
   resolveGroup,
   resolveGroupLayout,
   resolveLeaf,
-  tags
+  tags,
+  urlIdToText
 });