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

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.normalize("NFC"));
+  }
+  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 * as react from 'react';
 import { ReactElement } from 'react';
-import { OgManifestLike } from '../metadata/og-image.js';
-import { M as ManifestLike, I as IndexPageProps } from '../../../types-BzkZty3r.js';
+import { Metadata } from 'next';
+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 = {
@@ -11,7 +11,7 @@ type GroupRouteConfig = {
     ogManifest?: OgManifestLike;
     IndexPage: IndexPageComponent;
 };
-declare function createGroupPage({ group, manifest, IndexPage, }: GroupRouteConfig): () => Promise<react_jsx_runtime.JSX.Element>;
+declare function createGroupPage({ group, manifest, IndexPage, }: GroupRouteConfig): () => Promise<react.JSX.Element>;
 declare function createGroupMetadata({ group, manifest, ogManifest, }: GroupRouteConfig): Metadata;
 
 export { type GroupRouteConfig, type IndexPageComponent, createGroupMetadata, createGroupPage };

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

@@ -23,7 +23,8 @@ var isDev = process.env.NODE_ENV !== "production", isDebugEnabled = process.env.
 // src/lib/runtime/metadata/canonical-url.ts
 function canonicalUrl(manifest, path, group) {
   let origin = (group && manifest.groups[group]?.origin) ?? manifest.site.origin;
-  if (!origin) return path;
+  if (!origin)
+    return /^[a-z][a-z\d+.-]*:/i.test(path) ? path : new URL(path, "https://publish.invalid").pathname;
   try {
     return new URL(path, `${origin}/`).toString();
   } catch {
@@ -46,7 +47,12 @@ function agentReadableAlternates({
   return {
     ...canonical.startsWith("http") ? { canonical } : {},
     types: {
-      ...markdownPath ? { "text/markdown": normalizePath(markdownPath) } : {},
+      ...markdownPath ? {
+        "text/markdown": new URL(
+          normalizePath(markdownPath),
+          "https://publish.invalid"
+        ).pathname
+      } : {},
       "text/plain": "/llms.txt"
     }
   };
@@ -101,7 +107,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";
@@ -136,11 +142,11 @@ function createGroupMetadata({
     }) : void 0,
     ...createSocialMetadata({
       canonicalPath,
-      description,
+      description: groupData?.metadata?.openGraph?.description ?? description,
       group,
       manifest,
       ogManifest,
-      title
+      title: groupData?.metadata?.openGraph?.title ?? title
     })
   };
 }

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

@@ -1,8 +1,38 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { Metadata } from 'next';
+import * as react from 'react';
 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 { Metadata } from 'next';
+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;
+    robots?: {
+        index?: boolean;
+        follow?: boolean;
+    };
+    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,7 +41,9 @@ type PoweredByFooterComponent = (props: {
 type LeafRouteConfig = {
     group: string;
     manifest: ManifestLike;
+    markdownArtifactManifest?: Pick<MarkdownRouteArtifactManifest, "byMarkdownPath">;
     ogManifest?: OgManifestLike;
+    markdownRoutesEnabled?: boolean;
     Leaf: LeafComponent;
     PoweredByFooter?: PoweredByFooterComponent;
 };
@@ -27,8 +59,8 @@ 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 createLeafMetadata({ group, manifest, ogManifest, }: LeafRouteConfig): ({ params, }: PageRouteProps) => Promise<Metadata>;
+declare function createLeafPage({ group, manifest, markdownArtifactManifest, Leaf, PoweredByFooter, }: LeafRouteConfig): ({ params }: PageRouteProps) => Promise<react.JSX.Element>;
+declare function createLeafMetadata({ group, manifest, ogManifest, markdownRoutesEnabled, }: LeafRouteConfig): ({ params, }: PageRouteProps) => Promise<Metadata>;
 declare function createLeafStaticParams({ group, manifest }: LeafRouteConfig): () => {
     slug: string[];
 }[];

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

@@ -32,7 +32,8 @@ var isDev = process.env.NODE_ENV !== "production", isDebugEnabled = process.env.
 // src/lib/runtime/metadata/canonical-url.ts
 function canonicalUrl(manifest, path, group) {
   let origin = (group && manifest.groups[group]?.origin) ?? manifest.site.origin;
-  if (!origin) return path;
+  if (!origin)
+    return /^[a-z][a-z\d+.-]*:/i.test(path) ? path : new URL(path, "https://publish.invalid").pathname;
   try {
     return new URL(path, `${origin}/`).toString();
   } catch {
@@ -59,7 +60,12 @@ function agentReadableAlternates({
   return {
     ...canonical.startsWith("http") ? { canonical } : {},
     types: {
-      ...markdownPath ? { "text/markdown": normalizePath(markdownPath) } : {},
+      ...markdownPath ? {
+        "text/markdown": new URL(
+          normalizePath(markdownPath),
+          "https://publish.invalid"
+        ).pathname
+      } : {},
       "text/plain": "/llms.txt"
     }
   };
@@ -114,8 +120,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 +210,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 +219,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 });
   };
@@ -224,7 +231,8 @@ function createLeafPage({
 function createLeafMetadata({
   group,
   manifest,
-  ogManifest
+  ogManifest,
+  markdownRoutesEnabled
 }) {
   return async function({
     params
@@ -233,21 +241,22 @@ function createLeafMetadata({
     log.debug("[metadata]", `${group}/${slug.join("/")}`);
     let resolved = resolveLeaf(manifest, group, slug);
     return resolved ? {
-      title: resolved.page.title,
-      description: resolved.page.description,
+      title: resolved.page.frontmatter.title,
+      description: resolved.page.frontmatter.description,
+      ...resolved.page.frontmatter.metadata.robots ? { robots: resolved.page.frontmatter.metadata.robots } : {},
       alternates: agentReadableAlternates({
         canonicalPath: resolved.page.path,
         group,
         manifest,
-        markdownPath: markdownPathForHtmlPath(resolved.page.path)
+        markdownPath: markdownRoutesEnabled === !1 ? void 0 : markdownPathForHtmlPath(resolved.page.path)
       }),
       ...createSocialMetadata({
         canonicalPath: resolved.page.path,
-        description: resolved.page.description,
+        description: resolved.page.frontmatter.metadata.openGraph?.description ?? resolved.page.frontmatter.description,
         group,
         manifest,
         ogManifest,
-        title: resolved.page.title,
+        title: resolved.page.frontmatter.metadata.openGraph?.title ?? resolved.page.frontmatter.title,
         type: "article"
       })
     } : {};

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 * as react from 'react';
 import { ReactElement } from 'react';
-import { OgManifestLike } from '../metadata/og-image.js';
-import { b as RootPageProps, M as ManifestLike } from '../../../types-BzkZty3r.js';
+import { Metadata } from 'next';
+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 = {
@@ -10,7 +10,7 @@ type RootRouteConfig = {
     ogManifest?: OgManifestLike;
     RootPage: RootPageComponent;
 };
-declare function createRootPage({ manifest, RootPage }: RootRouteConfig): () => Promise<react_jsx_runtime.JSX.Element>;
+declare function createRootPage({ manifest, RootPage }: RootRouteConfig): () => Promise<react.JSX.Element>;
 declare function createRootMetadata({ manifest, ogManifest, }: RootRouteConfig): Metadata;
 
 export { type RootPageComponent, type RootRouteConfig, createRootMetadata, createRootPage };

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

@@ -21,7 +21,8 @@ var isDev = process.env.NODE_ENV !== "production", isDebugEnabled = process.env.
 // src/lib/runtime/metadata/canonical-url.ts
 function canonicalUrl(manifest, path, group) {
   let origin = (group && manifest.groups[group]?.origin) ?? manifest.site.origin;
-  if (!origin) return path;
+  if (!origin)
+    return /^[a-z][a-z\d+.-]*:/i.test(path) ? path : new URL(path, "https://publish.invalid").pathname;
   try {
     return new URL(path, `${origin}/`).toString();
   } catch {
@@ -44,7 +45,12 @@ function agentReadableAlternates({
   return {
     ...canonical.startsWith("http") ? { canonical } : {},
     types: {
-      ...markdownPath ? { "text/markdown": normalizePath(markdownPath) } : {},
+      ...markdownPath ? {
+        "text/markdown": new URL(
+          normalizePath(markdownPath),
+          "https://publish.invalid"
+        ).pathname
+      } : {},
       "text/plain": "/llms.txt"
     }
   };
@@ -98,12 +104,21 @@ function createSocialMetadata({
   };
 }
 
+// src/lib/shared/root-content-group.ts
+var ROOT_CONTENT_GROUP_KEY = "__root";
+
 // 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";
-  return cacheLife("page"), cacheTag(tags.site()), !rootManifest || !rootPage ? null : (cacheTag(tags.manifest(rootManifest.contentHash)), log.debug("[cache]", "root"), /* @__PURE__ */ jsx(rootPage, { site: rootManifest.site, tree: rootManifest.tree }));
+  if (cacheLife("page"), cacheTag(tags.site()), !rootManifest || !rootPage) return null;
+  cacheTag(tags.manifest(rootManifest.contentHash)), log.debug("[cache]", "root");
+  let RootPage = rootPage, navigation = rootManifest.groups[ROOT_CONTENT_GROUP_KEY]?.navigation ?? {
+    rootGroup: ROOT_CONTENT_GROUP_KEY,
+    items: []
+  };
+  return /* @__PURE__ */ jsx(RootPage, { site: rootManifest.site, navigation });
 }
 function createRootPage({ manifest, RootPage }) {
   return rootManifest = manifest, rootPage = RootPage, async function() {
@@ -125,10 +140,10 @@ function createRootMetadata({
     }),
     ...createSocialMetadata({
       canonicalPath: "/",
-      description,
+      description: manifest.site.metadata?.openGraph?.description ?? description,
       manifest,
       ogManifest,
-      title: manifest.site.name
+      title: manifest.site.metadata?.openGraph?.title ?? manifest.site.name
     })
   };
 }

package/dist/keyboard-shortcuts.d.ts

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
 import { ReactNode } from 'react';
 
 type Modifier = "mod" | "meta" | "ctrl" | "alt" | "shift";
@@ -26,7 +26,7 @@ type ShortcutRegistryApi = {
 };
 declare function KeyboardShortcutsProvider({ children, }: {
     children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
+}): react.JSX.Element;
 declare function useShortcut(combo: string | readonly string[], handler: ShortcutHandler, options?: ShortcutOptions): void;
 declare function useShortcutRegistry(): ShortcutRegistryApi;
 declare function formatShortcut(source: string): string[];

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,

package/dist/manifest-types-CcVPH_jh.d.ts

@@ -0,0 +1,83 @@
+type OgImageMetadata = string | {
+    src: string;
+    alt?: string;
+};
+type OgMetadata = {
+    title?: string;
+    description?: string;
+    image?: OgImageMetadata;
+};
+type PageStatus = "published" | "draft";
+type PageMetadata = {
+    openGraph?: OgMetadata;
+    robots?: {
+        index?: boolean;
+        follow?: boolean;
+    };
+};
+type PageFrontmatter<TCustom extends Record<string, unknown> = Record<string, unknown>> = TCustom & {
+    title: string;
+    description: string;
+    slug: string;
+    status: PageStatus;
+    metadata: PageMetadata;
+};
+type PageData<TCustom extends Record<string, unknown> = Record<string, unknown>> = {
+    fileID: string;
+    group: string;
+    path: string;
+    frontmatter: PageFrontmatter<TCustom>;
+    body: string;
+};
+type NavigationPageNode = {
+    id: string;
+    type: "page";
+    label: string;
+    href: string;
+    page: Omit<PageData, "body">;
+    children?: NavigationNode[];
+};
+type NavigationGroupNode = {
+    id: string;
+    type: "group";
+    label: string;
+    groupKey: string;
+    route: string;
+    presentation: "page" | "folder";
+    href?: string;
+    children: NavigationNode[];
+};
+type NavigationContainerNode = {
+    id: string;
+    type: "section" | "folder";
+    label: string;
+    children: NavigationNode[];
+};
+type NavigationLinkNode = {
+    id: string;
+    type: "link";
+    label: string;
+    href: string;
+};
+type NavigationViewNode = {
+    id: string;
+    type: "view";
+    label?: string;
+    viewId?: string;
+    items: NavigationNode[];
+};
+type NavigationSwitchViewNode = {
+    id: string;
+    type: "switch-view";
+    label: string;
+    target: string | {
+        view: string;
+    };
+};
+type NavigationNode = NavigationPageNode | NavigationGroupNode | NavigationContainerNode | NavigationLinkNode | NavigationViewNode | NavigationSwitchViewNode;
+type ResolvedNavigation = {
+    rootGroup: string;
+    items: NavigationNode[];
+};
+
+export type { ResolvedNavigation as R };

package/dist/resolvers/manifest-resolver.d.ts

@@ -1,11 +1,11 @@
-import React from 'react';
+import react__default from 'react';
 import { IndexPageProps, PageProps, ManifestLike, LayoutProps } from '../types.js';
 
 type ResolvedLeaf = PageProps;
 type ResolvedGroup = Omit<IndexPageProps, "children">;
 declare function resolveLeaf(manifest: ManifestLike, group: string, slug: string | string[]): ResolvedLeaf | null;
 declare function resolveGroup(manifest: ManifestLike, group: string): ResolvedGroup | null;
-declare function resolveGroupLayout(manifest: ManifestLike, group: string, children: React.ReactNode): LayoutProps | null;
+declare function resolveGroupLayout(manifest: ManifestLike, group: string, children: react__default.ReactNode): LayoutProps | null;
 declare function listStaticParams(manifest: ManifestLike, group: string): Array<{
     slug: string[];
 }>;