@publish.os/nextjs 0.0.1-alpha.90 → 0.0.1-alpha.91

package/dist/kernel/routes/metadata/sitemap.js

@@ -13,6 +13,93 @@ function canonicalUrl(manifest, path, group) {
   }
 }
 
+// src/lib/runtime/metadata/discovery-content.ts
+function discoveryOrigin(manifest, group) {
+  return (group ? manifest.groups[group]?.origin : void 0) ?? manifest.site.origin;
+}
+function pathWithin(path, basePath) {
+  return basePath === "/" || path === basePath || path.startsWith(`${basePath}/`);
+}
+function discoveryPages({
+  manifest,
+  group,
+  scope,
+  limit
+}) {
+  let origin = discoveryOrigin(manifest, group), basePath = group ? manifest.groups[group]?.path ?? "/" : "/", pages = manifest.pages.filter((page) => page.status !== "published" || discoveryOrigin(manifest, page.group) !== origin ? !1 : !group || scope === "site" ? !0 : pathWithin(page.path, basePath) ? page.group === group || scope !== "self" && page.group.startsWith(`${group}/`) : !1);
+  return limit ? pages.slice(0, limit) : pages;
+}
+function groupDiscoveryPages({
+  manifest,
+  pages
+}) {
+  let sections = /* @__PURE__ */ new Map();
+  for (let page of pages) {
+    let group = manifest.groups[page.group], key = group ? page.group : "", section = sections.get(key);
+    section || (section = {
+      ...group ? { group: page.group } : {},
+      title: group ? group.key === "__root" ? manifest.site.name : group.title : "Pages",
+      pages: []
+    }, sections.set(key, section)), section.pages.push(page);
+  }
+  return [...sections.values()].sort(
+    (a, b) => (manifest.groups[a.group ?? ""]?.path ?? "/").localeCompare(
+      manifest.groups[b.group ?? ""]?.path ?? "/"
+    ) || a.title.localeCompare(b.title)
+  );
+}
+
+// src/lib/runtime/metadata/llms-serialization.ts
+function inlineText(value) {
+  return value.replace(/[\r\n]+/g, " ").replace(/([\\`*_[\]<>])/g, "\\$1");
+}
+function markdownLink(link) {
+  let url = link.url.replace(
+    /[\s()<>]/g,
+    (value) => value === "(" ? "%28" : value === ")" ? "%29" : encodeURIComponent(value)
+  );
+  return `[${inlineText(link.title)}](${url})`;
+}
+function serializeLlmsIndex(input) {
+  let body = (input.sections ?? [
+    { title: "Pages", pages: input.pages ?? [] }
+  ]).map((section) => {
+    let lines = [
+      ...(section.links ?? []).map((link) => `- ${markdownLink(link)}`),
+      ...section.pages.map((page) => {
+        let description = input.includeDescriptions && page.description ? `: ${inlineText(page.description)}` : "", alternate = page.alternate ? ` (${markdownLink(page.alternate)})` : "";
+        return `- ${markdownLink(page)}${alternate}${description}`;
+      })
+    ];
+    return `## ${inlineText(section.title)}
+
+${lines.join(`
+`)}`;
+  }).join(`
+
+`), linkLines = (input.links ?? []).map(
+    (link) => `- ${markdownLink(link)}`
+  ), linkSection = linkLines.length ? `
+
+## Group LLM indexes
+
+${linkLines.join(`
+`)}` : "", otherGroupLines = (input.otherGroupLinks ?? []).map(
+    (link) => `- ${markdownLink(link)}`
+  ), otherGroupSection = otherGroupLines.length ? `
+
+## Other content groups
+
+${otherGroupLines.join(`
+`)}` : "";
+  return `# ${inlineText(input.title)}
+
+> ${inlineText(input.summary)}
+
+${body}${linkSection}${otherGroupSection}
+`;
+}
+
 // src/lib/runtime/response/cached-text-response.ts
 var CACHE_CONTROL = "public, max-age=300, s-maxage=3600, stale-while-revalidate=3600, must-revalidate", CDN_CACHE_CONTROL = "public, max-age=3600, stale-while-revalidate=3600, must-revalidate", SHORT_CACHE_CONTROL = "public, max-age=60, s-maxage=600, stale-while-revalidate=300, must-revalidate", SHORT_CDN_CACHE_CONTROL = "public, max-age=300, stale-while-revalidate=3600";
 function cacheControl(policy) {
@@ -36,32 +123,53 @@ function createCachedTextResponse(options) {
 // src/route-metadata-sitemap.ts
 var ROOT_CONTENT_GROUP_KEY = "__root";
 function xmlEscape(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/'/g, "&apos;").replace(/"/g, "&quot;");
 }
-function groupOrigin(manifest, groupKey) {
-  return manifest.groups[groupKey]?.origin ?? manifest.site.origin;
-}
-function pathInScope(path, basePath) {
-  return basePath === "/" || path === basePath || path.startsWith(`${basePath}/`);
+function sitemapDirectory(path) {
+  return path.slice(0, path.lastIndexOf("/") + 1) || "/";
 }
 function rootMountedGroup(manifest, origin) {
   return Object.values(manifest.groups).find(
-    (group) => group.key !== ROOT_CONTENT_GROUP_KEY && group.path === "/" && groupOrigin(manifest, group.key) === origin
+    (group) => group.key !== ROOT_CONTENT_GROUP_KEY && group.path === "/" && discoveryOrigin(manifest, group.key) === origin
   );
 }
 async function sitemapXml(manifest, options) {
   "use cache";
   cacheLife("page"), cacheTag(tags.site(), tags.sitemap(), tags.manifest(manifest.contentHash));
-  let targetGroup = options.group ? manifest.groups[options.group] : void 0, basePath = targetGroup?.path ?? "/", origin = targetGroup ? groupOrigin(manifest, targetGroup.key) : manifest.site.origin, homeGroup = targetGroup ?? rootMountedGroup(manifest, origin), groups = Object.values(manifest.groups).filter(
-    (group) => groupOrigin(manifest, group.key) === origin && pathInScope(group.path, basePath)
+  let targetGroup = options.group ? manifest.groups[options.group] : void 0, directory = sitemapDirectory(
+    options.path ?? `${targetGroup?.path === "/" ? "" : targetGroup?.path ?? ""}/sitemap.xml`
+  ), origin = targetGroup ? discoveryOrigin(manifest, targetGroup.key) : manifest.site.origin;
+  if (options.sitemaps)
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${[
+      ...new Set(
+        options.sitemaps.filter(
+          (sitemap) => discoveryOrigin(manifest, sitemap.group) === origin
+        ).filter(
+          (sitemap) => sitemap.path.startsWith(directory) && sitemap.path !== options.path
+        ).map(
+          (sitemap) => canonicalUrl(manifest, sitemap.path, sitemap.group)
+        )
+      )
+    ].map((url) => `  <sitemap><loc>${xmlEscape(url)}</loc></sitemap>`).join(`
+`)}
+</sitemapindex>
+`;
+  let homeGroup = targetGroup ?? rootMountedGroup(manifest, origin), groups = Object.values(manifest.groups).filter(
+    (group) => discoveryOrigin(manifest, group.key) === origin && (directory === "/" || group.path.startsWith(directory))
   ), urls = [
     {
       path: homeGroup?.path ?? "/",
       group: homeGroup?.key
     },
     ...groups.map((group) => ({ path: group.path, group: group.key })),
-    ...manifest.pages.filter((page) => page.status === "published").filter((page) => groupOrigin(manifest, page.group) === origin).filter((page) => pathInScope(page.path, basePath)).map((page) => ({ path: page.path, group: page.group }))
-  ];
+    ...manifest.pages.filter((page) => page.status === "published").filter((page) => discoveryOrigin(manifest, page.group) === origin).map((page) => ({ path: page.path, group: page.group }))
+  ].filter(
+    ({ path }) => (directory === "/" || path.startsWith(directory)) && !(options.exclude ?? []).some(
+      (sitemap) => discoveryOrigin(manifest, sitemap.group) === origin && path.startsWith(sitemapDirectory(sitemap.path))
+    )
+  );
   return `<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 ${[...new Map(
@@ -82,42 +190,74 @@ function createSitemapXmlRoute(manifest, options = {}) {
     });
   };
 }
-async function sitemapMarkdown(manifest, artifactManifest) {
-  let origin = manifest.site.origin, rootGroup = rootMountedGroup(manifest, origin), groups = Object.values(manifest.groups).filter((group) => group.key !== ROOT_CONTENT_GROUP_KEY).filter((group) => groupOrigin(manifest, group.key) === origin).sort((a, b) => a.path.localeCompare(b.path)).map(
-    (group) => `- [${group.title}](${canonicalUrl(manifest, group.path, group.key)})`
-  ), pages = manifest.pages.filter((page) => page.status === "published").filter((page) => groupOrigin(manifest, page.group) === origin).sort((a, b) => a.path.localeCompare(b.path)).map((page) => {
-    let markdownPath = artifactManifest.byHtmlPath[page.path], markdown = markdownPath ? ` ([Markdown](${canonicalUrl(manifest, markdownPath, page.group)}))` : "";
-    return `- [${page.title}](${canonicalUrl(manifest, page.path, page.group)})${markdown}`;
+async function sitemapMarkdown(manifest, artifactManifest, options) {
+  let origin = discoveryOrigin(manifest, options.group), targetGroup = options.group ? manifest.groups[options.group] : void 0, rootGroup = targetGroup?.key === ROOT_CONTENT_GROUP_KEY ? void 0 : targetGroup ?? rootMountedGroup(manifest, origin), groups = Object.values(manifest.groups).filter((group) => group.key !== ROOT_CONTENT_GROUP_KEY).filter((group) => discoveryOrigin(manifest, group.key) === origin).filter(
+    (group) => !targetGroup || options.scope === "site" || pathWithin(group.path, targetGroup.path) && (group.key === targetGroup.key || options.scope !== "self" && group.key.startsWith(`${targetGroup.key}/`))
+  ), pages = discoveryPages({ manifest, ...options }).sort(
+    (a, b) => a.path.localeCompare(b.path)
+  ), sections = groupDiscoveryPages({ manifest, pages });
+  for (let group of groups)
+    sections.some((section) => section.group === group.key) || sections.push({ group: group.key, title: group.title, pages: [] });
+  sections.sort(
+    (a, b) => (manifest.groups[a.group ?? ""]?.path ?? "/").localeCompare(
+      manifest.groups[b.group ?? ""]?.path ?? "/"
+    )
+  );
+  let links = options.links ?? [
+    { title: "LLMS index", path: "/llms.txt" },
+    { title: "Full LLMS index", path: "/llms-full.txt" },
+    { title: "XML sitemap", path: "/sitemap.xml" }
+  ];
+  return serializeLlmsIndex({
+    title: `${rootGroup?.title ?? manifest.site.name} Sitemap`,
+    summary: "Browse the published pages and their available Markdown versions.",
+    sections: [
+      ...links.length ? [
+        {
+          title: "Agent indexes",
+          pages: [],
+          links: links.map((link) => ({
+            title: link.title,
+            url: canonicalUrl(manifest, link.path, link.group)
+          }))
+        }
+      ] : [],
+      ...sections.map((section) => {
+        let group = manifest.groups[section.group ?? ""];
+        return {
+          title: section.title,
+          links: group && group.key !== ROOT_CONTENT_GROUP_KEY ? [
+            {
+              title: group.title,
+              url: canonicalUrl(manifest, group.path, group.key)
+            }
+          ] : [],
+          pages: section.pages.map((page) => {
+            let markdownPath = options.markdownAlternates === !1 ? void 0 : artifactManifest.byHtmlPath[page.path];
+            return {
+              title: page.title,
+              url: canonicalUrl(manifest, page.path, page.group),
+              ...markdownPath ? {
+                alternate: {
+                  title: "Markdown",
+                  url: canonicalUrl(manifest, markdownPath, page.group)
+                }
+              } : {}
+            };
+          })
+        };
+      })
+    ],
+    otherGroupLinks: options.otherGroupLinks?.map((link) => ({
+      title: link.title,
+      url: canonicalUrl(manifest, link.path, link.group)
+    }))
   });
-  return [
-    `# ${rootGroup?.title ?? manifest.site.name} Sitemap`,
-    "## Agent indexes",
-    `- [LLMS index](${canonicalUrl(manifest, "/llms.txt")})`,
-    `- [Full LLMS index](${canonicalUrl(manifest, "/llms-full.txt")})`,
-    `- [XML sitemap](${canonicalUrl(manifest, "/sitemap.xml")})`,
-    "## Sections",
-    groups.length ? groups.join(`
-`) : `- [${rootGroup?.title ?? "Home"}](${canonicalUrl(
-      manifest,
-      rootGroup?.path ?? "/",
-      rootGroup?.key
-    )})`,
-    "## Pages",
-    pages.length ? pages.join(`
-`) : `- [${rootGroup?.title ?? "Home"}](${canonicalUrl(
-      manifest,
-      rootGroup?.path ?? "/",
-      rootGroup?.key
-    )})`,
-    ""
-  ].join(`
-
-`);
 }
-function createSitemapMarkdownRoute(manifest, artifactManifest) {
+function createSitemapMarkdownRoute(manifest, artifactManifest, options = {}) {
   return async function() {
     return createCachedTextResponse({
-      body: await sitemapMarkdown(manifest, artifactManifest),
+      body: await sitemapMarkdown(manifest, artifactManifest, options),
       contentType: "text/markdown; charset=utf-8"
     });
   };

package/dist/kernel/routes/not-found.d.ts

@@ -0,0 +1,34 @@
+type NotFoundLink = {
+    title: string;
+    href: string;
+    description?: string;
+    kind?: "sitemap" | "sitemap-md" | "llms" | "llms-full";
+};
+type NotFoundScope = {
+    id: string;
+    path: string;
+    group?: string;
+    origin?: string;
+    describedBy?: string;
+    htmlPath: string;
+    recommendations: readonly NotFoundLink[];
+    indexes: readonly NotFoundLink[];
+    markdown: string;
+};
+declare function resolveNotFoundScope({ scopes, pathname, }: {
+    scopes: readonly NotFoundScope[];
+    pathname: string;
+}): NotFoundScope | undefined;
+declare function serializeNotFoundMarkdown({ recommendations, indexes, }: {
+    recommendations: readonly NotFoundLink[];
+    indexes: readonly NotFoundLink[];
+}): string;
+declare function createNotFoundTextResponse({ scope, pathname, method, contentType, vary, }: {
+    scope?: NotFoundScope;
+    pathname?: string;
+    method: string;
+    contentType?: "text/markdown; charset=utf-8" | "text/plain; charset=utf-8";
+    vary?: boolean;
+}): Response;
+
+export { type NotFoundLink, type NotFoundScope, createNotFoundTextResponse, resolveNotFoundScope, serializeNotFoundMarkdown };

package/dist/kernel/routes/not-found.js

@@ -0,0 +1,213 @@
+// src/lib/runtime/response/cached-text-response.ts
+var CACHE_CONTROL = "public, max-age=300, s-maxage=3600, stale-while-revalidate=3600, must-revalidate", CDN_CACHE_CONTROL = "public, max-age=3600, stale-while-revalidate=3600, must-revalidate", SHORT_CACHE_CONTROL = "public, max-age=60, s-maxage=600, stale-while-revalidate=300, must-revalidate", SHORT_CDN_CACHE_CONTROL = "public, max-age=300, stale-while-revalidate=3600";
+function cacheControl(policy) {
+  return !policy || policy === "default" ? CACHE_CONTROL : policy === "short" ? SHORT_CACHE_CONTROL : policy;
+}
+function cdnCacheControl(policy) {
+  return !policy || policy === "default" ? CDN_CACHE_CONTROL : policy === "short" ? SHORT_CDN_CACHE_CONTROL : policy;
+}
+function cachedTextHeaders(contentType, options = {}) {
+  let headers = new Headers(options.headers);
+  return 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"), options.noindex && headers.set("x-robots-tag", "noindex"), headers;
+}
+function createCachedTextResponse(options) {
+  let status = options.status ?? 200, method = options.method ?? "GET", headers = cachedTextHeaders(options.contentType, options);
+  return new Response(method === "HEAD" ? null : options.body, {
+    headers,
+    status
+  });
+}
+
+// src/route-not-found.ts
+var MAX_PATH_LENGTH = 2048, UNSAFE_PATH_CHARACTERS = /[\p{Cc}\p{Cs}\u200b-\u200f\u2028-\u202f\u2060-\u206f\ufeff]/u, INTERNAL_PATHS = ["/__publishos", "/_next", "/_not-found", "/publishos"], DEFAULT_MARKDOWN = serializeNotFoundMarkdown({
+  recommendations: [],
+  indexes: []
+});
+function normalizePublicPath(pathname) {
+  let path = pathname.split(/[?#]/u, 1)[0];
+  if (!path?.startsWith("/") || path.startsWith("//") || path.length > MAX_PATH_LENGTH || UNSAFE_PATH_CHARACTERS.test(path))
+    return;
+  let segments = [];
+  for (let segment of path.split("/")) {
+    if (!segment) continue;
+    let decoded;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+      return;
+    }
+    if (decoded === "." || decoded === ".." || /[/\\]/u.test(decoded) || /%[\da-f]{2}/iu.test(decoded) || UNSAFE_PATH_CHARACTERS.test(decoded))
+      return;
+    segments.push(decoded);
+  }
+  return `/${segments.join("/")}`;
+}
+function containsPath({ parent, path }) {
+  return parent === "/" || path === parent || path.startsWith(`${parent}/`);
+}
+function missingPagePath(pathname) {
+  let normalized = normalizePublicPath(pathname);
+  if (!normalized) return;
+  let path = normalized.endsWith(".md") ? normalized.slice(0, -3) || "/" : normalized;
+  return INTERNAL_PATHS.some((parent) => containsPath({ parent, path })) ? void 0 : path;
+}
+function resolveNotFoundScope({
+  scopes,
+  pathname
+}) {
+  let path = missingPagePath(pathname);
+  if (!path) return;
+  let matched, matchedLength = -1;
+  for (let scope of scopes) {
+    let scopePath = normalizePublicPath(scope.path);
+    !scopePath || !containsPath({ parent: scopePath, path }) || (scopePath.length > matchedLength || scopePath.length === matchedLength && scope.group && !matched?.group) && (matched = scope, matchedLength = scopePath.length);
+  }
+  return matched;
+}
+function trustedHostname(origin) {
+  if (origin)
+    try {
+      let url = new URL(origin);
+      return !["http:", "https:"].includes(url.protocol) || url.username || url.password ? void 0 : url.host.replace(/`/gu, "%60");
+    } catch {
+      return;
+    }
+}
+function requestExplanation({
+  pathname,
+  origin
+}) {
+  let path = pathname.split("/").map(encodeURIComponent).join("/"), hostname = trustedHostname(origin);
+  return `No page exists at \`${path}\`${hostname ? ` on ${hostname}` : ""}.`;
+}
+function indexKind(link) {
+  if (link.kind) return link.kind;
+  switch (link.title) {
+    case "Sitemap":
+      return "sitemap";
+    case "Markdown sitemap":
+      return "sitemap-md";
+    case "llms.txt":
+    case "LLMS index":
+      return "llms";
+    case "llms-full.txt":
+      return "llms-full";
+    default:
+      return;
+  }
+}
+function publicRecoveryHref(href) {
+  if (href.includes("\\") || UNSAFE_PATH_CHARACTERS.test(href))
+    return;
+  let relative = href.startsWith("/") && !href.startsWith("//");
+  try {
+    let url = new URL(
+      href,
+      relative ? "https://publishos.invalid" : void 0
+    );
+    return !["http:", "https:"].includes(url.protocol) || url.username || url.password ? void 0 : relative ? `${url.pathname}${url.search}${url.hash}` : url.href;
+  } catch {
+    return;
+  }
+}
+function markdownText(value) {
+  return value.replace(/\s+/gu, " ").replace(/[\p{Cc}\p{Cs}]/gu, "").trim().replace(/[\\`*_[\]{}<>|~]/gu, "\\$&");
+}
+function markdownLink(link) {
+  let title = markdownText(link.title), href = publicRecoveryHref(link.href)?.replace(
+    /[()`<>]/gu,
+    (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+  if (!title || !href) return;
+  let description = link.description ? markdownText(link.description) : void 0;
+  return `- [${title}](${href})${description ? `: ${description}` : ""}`;
+}
+function serializeNotFoundMarkdown({
+  recommendations,
+  indexes
+}) {
+  let sections = [
+    { title: "Recommendations", links: recommendations },
+    { title: "For crawlers and agents", links: indexes }
+  ], lines = [
+    "# 404 \u2014 Not Found",
+    "",
+    "This page does not exist. Please check the URL and try again.",
+    ""
+  ];
+  for (let section of sections) {
+    let links = section.links.map(markdownLink).filter((link) => link !== void 0);
+    links.length && lines.push(`## ${section.title}`, "", ...links, "");
+  }
+  return lines.join(`
+`);
+}
+function discoveryHeaders(scope) {
+  let headers = new Headers(), links = [];
+  for (let link of scope?.indexes ?? []) {
+    let kind = indexKind(link), href = /[\s<>"\\]/u.test(link.href) ? void 0 : publicRecoveryHref(link.href);
+    if (!(!kind || !href))
+      switch (kind) {
+        case "llms":
+          if (scope?.describedBy !== void 0) break;
+          links.push(`<${href}>; rel="describedby"; type="text/plain"`), headers.set("x-publishos-llms", href);
+          break;
+        case "llms-full":
+          links.push(
+            `<${href}>; rel="related"; type="text/plain"; title="Full content"`
+          );
+          break;
+        case "sitemap":
+        case "sitemap-md":
+          links.push(
+            `<${href}>; rel="sitemap"; type="${kind === "sitemap-md" ? "text/markdown" : "application/xml"}"`
+          ), headers.set("x-publishos-sitemap", href);
+          break;
+      }
+  }
+  if (scope?.describedBy !== void 0) {
+    let href = /[\s<>"\\]/u.test(scope.describedBy) ? void 0 : publicRecoveryHref(scope.describedBy);
+    href && (links.push(`<${href}>; rel="describedby"; type="text/plain"`), headers.set("x-publishos-llms", href));
+  }
+  return links.length && headers.set("link", links.join(", ")), headers;
+}
+function createNotFoundTextResponse({
+  scope,
+  pathname,
+  method,
+  contentType = "text/markdown; charset=utf-8",
+  vary = !1
+}) {
+  let path = pathname === void 0 ? void 0 : missingPagePath(pathname), resolvedScope = scope && (pathname === void 0 || resolveNotFoundScope({ scopes: [scope], pathname })) ? scope : void 0, body = resolvedScope?.markdown ?? DEFAULT_MARKDOWN;
+  if (resolvedScope && path) {
+    let explanation = requestExplanation({
+      pathname: path,
+      origin: scope?.origin
+    }), headingEnd = body.indexOf(`
+
+`);
+    body = headingEnd === -1 ? `${body}
+
+${explanation}
+` : `${body.slice(0, headingEnd)}
+
+${explanation}
+
+${body.slice(headingEnd + 2)}`;
+  }
+  let headers = discoveryHeaders(resolvedScope);
+  return vary && headers.set("vary", "Accept, User-Agent"), createCachedTextResponse({
+    body,
+    cachePolicy: "short",
+    contentType,
+    headers,
+    method,
+    noindex: !0,
+    status: 404
+  });
+}
+export {
+  createNotFoundTextResponse,
+  resolveNotFoundScope,
+  serializeNotFoundMarkdown
+};

package/dist/kernel/routes/pages/group.d.ts

@@ -1,8 +1,8 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { Metadata } from 'next';
 import { ReactElement } from 'react';
-import { OgManifestLike } from '../metadata/og-image.js';
-import { M as ManifestLike, I as IndexPageProps } from '../../../types-BzkZty3r.js';
+import { O as OgManifestLike } from '../../../route-metadata-og-image-BeKKFHg7.js';
+import { ManifestLike, IndexPageProps } from '../../../types.js';
 
 type IndexPageComponent = (props: IndexPageProps) => ReactElement | Promise<ReactElement>;
 type GroupRouteConfig = {

package/dist/kernel/routes/pages/group.js

@@ -101,7 +101,7 @@ function createSocialMetadata({
 }
 
 // src/route-page-group.tsx
-import { jsx } from "react/jsx-runtime";
+import { jsx } from "@publish.os/nextjs/jsx-runtime";
 var manifests = /* @__PURE__ */ new Map(), indexPages = /* @__PURE__ */ new Map();
 async function CachedGroupPage({ group }) {
   "use cache";

package/dist/kernel/routes/pages/leaf.d.ts

@@ -1,8 +1,34 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { Metadata } from 'next';
 import { ReactElement, ReactNode } from 'react';
-import { OgManifestLike } from '../metadata/og-image.js';
-import { a as PageProps, M as ManifestLike, R as ResolvedAttribution } from '../../../types-BzkZty3r.js';
+import { O as OgManifestLike } from '../../../route-metadata-og-image-BeKKFHg7.js';
+import { PageProps, ManifestLike, ResolvedAttribution } from '../../../types.js';
+
+type MarkdownRouteArtifact = {
+    body: string;
+    bodyHash?: string;
+    byteSize?: number;
+    htmlPath: string;
+    markdownPath: string;
+    sourceHash?: string;
+    title: string;
+};
+type MarkdownRouteArtifactIndexEntry = Omit<MarkdownRouteArtifact, "body"> & {
+    shardId: string;
+};
+type MarkdownRouteArtifactIndex = Record<string, MarkdownRouteArtifactIndexEntry>;
+type MarkdownRouteArtifactShardMetadata = {
+    byteSize: number;
+    contentHash: string;
+    id: string;
+    modulePath: string;
+    pageCount: number;
+};
+type MarkdownRouteArtifactManifest = {
+    byHtmlPath: Record<string, string>;
+    byMarkdownPath: MarkdownRouteArtifactIndex;
+    shards: MarkdownRouteArtifactShardMetadata[];
+};
 
 type LeafComponent = (props: PageProps) => ReactElement | Promise<ReactElement>;
 type PoweredByFooterComponent = (props: {
@@ -11,6 +37,7 @@ type PoweredByFooterComponent = (props: {
 type LeafRouteConfig = {
     group: string;
     manifest: ManifestLike;
+    markdownArtifactManifest?: Pick<MarkdownRouteArtifactManifest, "byMarkdownPath">;
     ogManifest?: OgManifestLike;
     Leaf: LeafComponent;
     PoweredByFooter?: PoweredByFooterComponent;
@@ -27,7 +54,7 @@ declare function appendPoweredByFooter({ footer, node, }: {
     node: ReactNode;
     placed: boolean;
 };
-declare function createLeafPage({ group, manifest, Leaf, PoweredByFooter, }: LeafRouteConfig): ({ params }: PageRouteProps) => Promise<react_jsx_runtime.JSX.Element>;
+declare function createLeafPage({ group, manifest, markdownArtifactManifest, Leaf, PoweredByFooter, }: LeafRouteConfig): ({ params }: PageRouteProps) => Promise<react_jsx_runtime.JSX.Element>;
 declare function createLeafMetadata({ group, manifest, ogManifest, }: LeafRouteConfig): ({ params, }: PageRouteProps) => Promise<Metadata>;
 declare function createLeafStaticParams({ group, manifest }: LeafRouteConfig): () => {
     slug: string[];

package/dist/kernel/routes/pages/leaf.js

@@ -114,8 +114,8 @@ function createSocialMetadata({
 }
 
 // src/route-page-leaf.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
-var manifests = /* @__PURE__ */ new Map(), leaves = /* @__PURE__ */ new Map(), poweredByFooters = /* @__PURE__ */ new Map();
+import { jsx, jsxs } from "@publish.os/nextjs/jsx-runtime";
+var manifests = /* @__PURE__ */ new Map(), markdownArtifactIndexes = /* @__PURE__ */ new Map(), leaves = /* @__PURE__ */ new Map(), poweredByFooters = /* @__PURE__ */ new Map();
 function hasClassName(value, className) {
   return typeof value == "string" && value.split(/\s+/).includes(className);
 }
@@ -204,7 +204,7 @@ async function CachedLeafPage({
   (!manifest || !Leaf) && notFound(), cacheTag(tags.manifest(manifest.contentHash)), log.debug("[cache]", `${group}/${slug.join("/")}`);
   let resolved = resolveLeaf(manifest, group, slug);
   resolved || notFound();
-  let attribution = manifest.attribution?.[group] ?? { enabled: !1 }, leaf = await Leaf(resolved), footer = attribution.enabled && PoweredByFooter ? /* @__PURE__ */ jsx(PoweredByFooter, { attribution }) : null, placed = footer ? appendPoweredByFooter({ footer, node: leaf }) : { node: leaf, placed: !0 };
+  let attribution = manifest.attribution?.[group] ?? { enabled: !1 }, markdownRevision = markdownArtifactIndexes.get(group)?.[markdownPathForHtmlPath(resolved.page.path)]?.bodyHash, leaf = await Leaf({ ...resolved, markdownRevision }), footer = attribution.enabled && PoweredByFooter ? /* @__PURE__ */ jsx(PoweredByFooter, { attribution }) : null, placed = footer ? appendPoweredByFooter({ footer, node: leaf }) : { node: leaf, placed: !0 };
   return /* @__PURE__ */ jsxs("div", { className: "flex min-h-full min-w-0 flex-1 flex-col", children: [
     placed.node,
     footer && !placed.placed ? footer : null
@@ -213,10 +213,11 @@ async function CachedLeafPage({
 function createLeafPage({
   group,
   manifest,
+  markdownArtifactManifest,
   Leaf,
   PoweredByFooter
 }) {
-  return manifests.set(group, manifest), leaves.set(group, Leaf), PoweredByFooter ? poweredByFooters.set(group, PoweredByFooter) : poweredByFooters.delete(group), async function({ params }) {
+  return manifests.set(group, manifest), markdownArtifactManifest ? markdownArtifactIndexes.set(group, markdownArtifactManifest.byMarkdownPath) : markdownArtifactIndexes.delete(group), leaves.set(group, Leaf), PoweredByFooter ? poweredByFooters.set(group, PoweredByFooter) : poweredByFooters.delete(group), async function({ params }) {
     let { slug = [] } = await params;
     return log.debug("[render]", `${group}/${slug.join("/")}`), /* @__PURE__ */ jsx(CachedLeafPage, { group, slug });
   };

package/dist/kernel/routes/pages/root.d.ts

@@ -1,8 +1,8 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { Metadata } from 'next';
 import { ReactElement } from 'react';
-import { OgManifestLike } from '../metadata/og-image.js';
-import { b as RootPageProps, M as ManifestLike } from '../../../types-BzkZty3r.js';
+import { O as OgManifestLike } from '../../../route-metadata-og-image-BeKKFHg7.js';
+import { RootPageProps, ManifestLike } from '../../../types.js';
 
 type RootPageComponent = (props: RootPageProps) => ReactElement | Promise<ReactElement>;
 type RootRouteConfig = {

package/dist/kernel/routes/pages/root.js

@@ -99,7 +99,7 @@ function createSocialMetadata({
 }
 
 // src/route-page-root.tsx
-import { jsx } from "react/jsx-runtime";
+import { jsx } from "@publish.os/nextjs/jsx-runtime";
 var rootManifest, rootPage;
 async function CachedRootPage() {
   "use cache";

package/dist/keyboard-shortcuts.js

@@ -10,7 +10,7 @@ import {
   useMemo,
   useRef
 } from "react";
-import { jsx } from "react/jsx-runtime";
+import { jsx } from "@publish.os/nextjs/jsx-runtime";
 var DEFAULT_OPTIONS = {
   description: "",
   enabled: !0,