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

package/dist/{chunk-726GV2NF.js → chunk-DZ3VWEV5.js}

@@ -1,45 +1,64 @@
 import {
-  supportedNextjsSourceImports
-} from "./chunk-NECL5IBJ.js";
+  AppError as AppError2,
+  ERROR_CODES,
+  assertPublishOsSourceBoundary
+} from "./chunk-7NY22B5U.js";
 import {
+  FrontmatterParseError,
+  MdxIconImportError,
   ROOT_CONTENT_GROUP_KEY,
   ROOT_CONTENT_GROUP_TITLE,
   assertSourceDependency,
+  authoredDate,
   buildFaviconsAndLogos,
   buildMediaAssets,
   collectBindingNames,
+  convertMdxToMarkdown,
   groupedMdxExports,
   joinUrlPath,
-  localCssImports,
   mdxComponentExportName,
   namedValueExports,
   normalizeSlugPath,
   normalizeUrlPath,
-  replacedMdxSourceFiles
-} from "./chunk-535TM4A5.js";
+  originalDefaultComponentSourcePath,
+  parseSourceFrontmatter,
+  replacedMdxSourceFiles,
+  supportedNextjsSourceImports,
+  validateMdxIconImports
+} from "./chunk-DX7PXFCM.js";
 import {
-  AppError as AppError2,
-  ERROR_CODES,
-  assertPublishOsSourceBoundary
-} from "./chunk-7OGTPSKI.js";
+  isFrameworkNamespacePath
+} from "./chunk-EFO6AWXN.js";
+import {
+  localCssImports
+} from "./chunk-5KAD7W53.js";
 import {
   isApprovedPublishOsPath,
   isExcludedSourcePath,
-  isFrameworkNamespacePath,
   isReservedFrameworkPath,
   isSameOrDescendant
-} from "./chunk-YLTOLYWM.js";
+} from "./chunk-WL75GQ5M.js";
 import {
   runtimePackageVersion
 } from "./chunk-AI2UULNX.js";
 import {
-  AppError,
   readInstalledFrameworkLocation
-} from "./chunk-WDY4IK6Z.js";
+} from "./chunk-5J3YUNRY.js";
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
 
 // src/lib/compiler/validation/validate-publish-os-source.ts
 import { readdir as readdir3, readFile as readFile5, stat as stat3 } from "fs/promises";
-import { basename, dirname, extname as extname3, relative as relative4, resolve as resolve7, sep } from "path";
+import {
+  basename as basename2,
+  dirname,
+  extname as extname4,
+  parse,
+  relative as relative4,
+  resolve as resolve7,
+  sep
+} from "path";
 import ts2 from "typescript";
 
 // src/lib/compiler/source/diagnostics/diagnostic-store.ts
@@ -48,7 +67,7 @@ var diagnosticSchema = z.object({
   code: z.string(),
   level: z.union([z.literal("error"), z.literal("warning")]),
   message: z.string(),
-  details: z.record(z.unknown()).optional()
+  details: z.record(z.string(), z.unknown()).optional()
 }), DiagnosticStore = class {
   diagnostics = [];
   add(diagnostic) {
@@ -86,11 +105,22 @@ import { resolve } from "path";
 
 // src/lib/compiler/source/config/format-config-issues.ts
 function issueMessages(issue) {
-  return issue.code === "invalid_union" ? issue.unionErrors.flatMap(
-    (error) => error.issues.flatMap(issueMessages)
-  ) : issue.code === "unrecognized_keys" ? issue.keys.map(
-    (key) => `${[...issue.path, key].join(".")}: Unknown field.`
-  ) : [`${issue.path.join(".") || "(root)"}: ${issue.message}`];
+  return issue.code === "invalid_union" ? issue.errors.flatMap(
+    (issues) => issues.flatMap(
+      (nestedIssue) => issueMessages({
+        ...nestedIssue,
+        path: [...issue.path, ...nestedIssue.path]
+      })
+    )
+  ) : issue.code === "unrecognized_keys" ? issue.keys.map((key) => {
+    let path = [...issue.path, key].join(".");
+    return issue.path.join(".") === "media.assets" && [
+      "maxImageBytes",
+      "maxVideoBytes",
+      "maxTotalBytes",
+      "maxFileCount"
+    ].includes(key) ? `${path}: Media limits are fixed by PublishOS. Remove this field.` : `${path}: Unknown field.`;
+  }) : [`${issue.path.join(".") || "(root)"}: ${issue.message}`];
 }
 function formatConfigIssues(error) {
   return [...new Set(error.issues.flatMap(issueMessages))].join(`
@@ -100,68 +130,115 @@ function formatConfigIssues(error) {
 // src/lib/compiler/source/config/publish-os-config-schema.ts
 import { z as z4 } from "zod";
 
-// src/lib/compiler/source/config/og-metadata-schema.ts
+// src/lib/compiler/source/config/metadata-schema.ts
 import { z as z2 } from "zod";
-var ogImageSchema = z2.union([
-  z2.string().min(1),
-  z2.object({ src: z2.string().min(1), alt: z2.string().optional() }).strict()
-]), ogIndexMetadataSchema = z2.object({
+var imagePathSchema = z2.string().min(1).refine((value) => {
+  if (value.startsWith("/assets/") && value.length > 8)
+    return !0;
+  try {
+    return new URL(value).protocol === "https:";
+  } catch {
+    return !1;
+  }
+}, "Use a nonempty /assets/ path or an absolute HTTPS URL."), imageSchema = z2.union([
+  imagePathSchema,
+  z2.object({ src: imagePathSchema, alt: z2.string().optional() }).strict()
+]), socialFields = {
   title: z2.string().optional(),
   description: z2.string().optional(),
-  image: ogImageSchema.optional(),
-  scope: z2.enum(["page", "subtree"]).optional()
-}).strict().refine((value) => value.scope === void 0 || value.image !== void 0, {
-  message: "Set og.image when you set og.scope.",
-  path: ["scope"]
-});
+  image: imageSchema.optional()
+}, pageMetadataSchema = z2.object({
+  openGraph: z2.object(socialFields).strict().optional(),
+  robots: z2.object({ index: z2.boolean().optional(), follow: z2.boolean().optional() }).strict().optional()
+}).strict(), indexMetadataSchema = z2.object({
+  openGraph: z2.object({
+    ...socialFields,
+    scope: z2.enum(["page", "subtree"]).optional()
+  }).strict().refine(
+    (value) => value.scope === void 0 || value.image !== void 0,
+    {
+      message: "Set metadata.openGraph.image when setting scope.",
+      path: ["scope"]
+    }
+  ).optional()
+}).strict();
 
 // src/lib/compiler/source/config/publish-os-group-schema.ts
 import { z as z3 } from "zod";
-var treeNodeSchema = z3.lazy(
-  () => z3.union([
-    z3.object({
-      type: z3.literal("section"),
-      id: z3.string(),
-      title: z3.string(),
-      children: z3.array(treeNodeSchema)
-    }),
+var navigationSortSchema = z3.object({
+  source: z3.literal("frontmatter"),
+  field: z3.string().min(1),
+  type: z3.enum(["date", "number"]),
+  direction: z3.enum(["asc", "desc"]).default("asc")
+}).strict(), navigationEntrySchema = z3.lazy(
+  () => z3.discriminatedUnion("type", [
     z3.object({
       type: z3.literal("page"),
-      file: z3.string(),
-      title: z3.string().optional(),
-      slug: z3.string().optional()
-    }),
+      file: z3.string().min(1).optional(),
+      group: z3.string().min(1).optional(),
+      label: z3.string().min(1).optional(),
+      items: z3.array(navigationEntrySchema).optional(),
+      navigation: z3.lazy(() => navigationConfigSchema).optional()
+    }).strict(),
+    z3.object({
+      type: z3.literal("folder"),
+      group: z3.string().min(1).optional(),
+      label: z3.string().min(1),
+      items: z3.array(navigationEntrySchema).optional(),
+      navigation: z3.lazy(() => navigationConfigSchema).optional()
+    }).strict(),
+    z3.object({
+      type: z3.literal("section"),
+      label: z3.string().min(1),
+      items: z3.array(navigationEntrySchema)
+    }).strict(),
     z3.object({
       type: z3.literal("link"),
-      id: z3.string(),
-      title: z3.string(),
-      url: z3.string()
-    }),
+      label: z3.string().min(1),
+      url: z3.string().min(1)
+    }).strict(),
     z3.object({
-      type: z3.literal("folder"),
-      id: z3.string(),
-      title: z3.string(),
-      group: z3.string().optional(),
-      children: z3.array(treeNodeSchema).optional()
-    })
-  ])
-), groupListSchema = z3.object({
-  source: z3.enum(["content", "ids"]),
-  ids: z3.array(z3.string()).optional(),
-  sort: z3.object({
-    by: z3.string(),
-    direction: z3.enum(["asc", "desc"]).optional()
-  }).optional(),
-  prevNext: z3.boolean().optional()
-}).strict(), outputScopeSchema = z3.enum(["site", "group", "self"]), outputStatusSchema = z3.enum(["published", "draft", "archived"]), outputDeclarationSchema = z3.object({
+      type: z3.literal("view"),
+      id: z3.string().min(1).optional(),
+      label: z3.string().min(1).optional(),
+      items: z3.array(navigationEntrySchema)
+    }).strict(),
+    z3.object({
+      type: z3.literal("switch-view"),
+      label: z3.string().min(1),
+      target: z3.union([
+        z3.string().min(1),
+        z3.object({ view: z3.string().min(1) }).strict()
+      ])
+    }).strict()
+  ]).superRefine((entry, context) => {
+    entry.type === "page" && entry.file && entry.group && context.addIssue({
+      code: "custom",
+      path: ["group"],
+      message: 'A page navigation entry cannot set both "file" and "group". Use "file" for a page or "group" for a group placement.'
+    });
+  })
+), navigationConfigSchema = z3.object({
+  items: z3.array(navigationEntrySchema),
+  sort: z3.unknown().optional()
+}).strict().transform(({ items, sort }) => {
+  if (sort === void 0) return { items };
+  let parsedSort = navigationSortSchema.safeParse(sort);
+  return parsedSort.success ? { items, sort: parsedSort.data } : {
+    items,
+    sortWarning: 'Invalid navigation sort config. Use source "frontmatter", a field, type "date" or "number", and direction "asc" or "desc". Filename order is used.'
+  };
+}), outputScopeSchema = z3.enum(["site", "group", "self"]), outputDeclarationSchema = z3.object({
   path: z3.string().min(1),
   scope: outputScopeSchema.optional(),
   description: z3.string().optional(),
   limit: z3.number().int().positive().optional()
-}).strict(), outputDefaultsDeclarationSchema = z3.object({
+}).strict(), sitemapOutputSchema = outputDeclarationSchema.extend({
+  path: z3.string().min(1).optional(),
+  mode: z3.enum(["index", "urls"]).optional()
+}), outputDefaultsDeclarationSchema = z3.object({
   scope: outputScopeSchema.optional(),
   limit: z3.number().int().positive().optional(),
-  status: z3.array(outputStatusSchema).optional(),
   includeDescriptions: z3.boolean().optional()
 }).strict(), feedsOutputSchema = z3.object({
   rss: outputDeclarationSchema.optional(),
@@ -172,10 +249,12 @@ var treeNodeSchema = z3.lazy(
   atom: outputDefaultsDeclarationSchema.optional(),
   json: outputDefaultsDeclarationSchema.optional()
 }).strict(), outputsSchema = z3.object({
-  llms: outputDeclarationSchema.optional(),
+  llms: outputDeclarationSchema.or(z3.literal(!1)).optional(),
+  llmsFull: outputDeclarationSchema.or(z3.literal(!1)).optional(),
   feeds: feedsOutputSchema.optional(),
-  robots: outputDeclarationSchema.optional(),
-  sitemap: outputDeclarationSchema.optional()
+  robots: outputDeclarationSchema.or(z3.literal(!1)).optional(),
+  sitemap: sitemapOutputSchema.or(z3.literal(!1)).optional(),
+  sitemapMarkdown: outputDeclarationSchema.or(z3.literal(!1)).optional()
 }).strict(), outputDefaultsSchema = z3.object({
   llms: outputDefaultsDeclarationSchema.optional(),
   feeds: feedsOutputDefaultsSchema.optional()
@@ -237,66 +316,35 @@ var httpsOriginSchema = z3.string().transform((value) => normalizeHttpsOrigin(va
 ]), fontConfigSchema = z3.record(
   z3.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
   fontRoleSchema
-), groupConfigDocumentSchema = z3.lazy(
-  () => z3.object({
-    origin: httpsOriginSchema.optional(),
-    og: ogIndexMetadataSchema.optional(),
-    title: z3.string().optional(),
-    slug: z3.string().optional(),
-    path: z3.string().regex(/^\//).optional(),
-    mode: z3.enum(["tree", "list"]).optional(),
-    theme: groupThemeSchema.optional(),
-    fonts: fontConfigSchema.optional(),
-    meta: z3.record(z3.unknown()).optional(),
-    tree: z3.array(treeNodeSchema).optional(),
-    list: groupListSchema.optional(),
-    outputs: outputsSchema.optional(),
-    outputDefaults: outputDefaultsSchema.optional()
-  }).strict()
-);
+), groupConfigDocumentSchema = z3.object({
+  origin: httpsOriginSchema.optional(),
+  metadata: indexMetadataSchema.optional(),
+  title: z3.string().optional(),
+  slug: z3.string().optional(),
+  path: z3.string().regex(/^\//).optional(),
+  theme: groupThemeSchema.optional(),
+  fonts: fontConfigSchema.optional(),
+  meta: z3.record(z3.string(), z3.unknown()).optional(),
+  navigation: navigationConfigSchema.optional(),
+  outputs: outputsSchema.optional(),
+  outputDefaults: outputDefaultsSchema.optional()
+}).strict();
 
 // src/lib/compiler/source/config/publish-os-config-schema.ts
 var siteSchema = z4.object({
   name: z4.string().optional(),
   description: z4.string().optional()
-}).strict(), runtimePackageMessage = 'Set runtime to "@publish.os/nextjs@<exact-version>". Replace <exact-version> with the exact framework version for this source.', runtimeSchema = z4.string({
-  required_error: runtimePackageMessage,
-  invalid_type_error: runtimePackageMessage
-}).refine((value) => runtimePackageVersion(value) !== void 0, {
+}).strict(), runtimePackageMessage = 'Set runtime to "@publish.os/nextjs@<exact-version>". Replace <exact-version> with the exact framework version for this source.', runtimeSchema = z4.string({ error: runtimePackageMessage }).refine((value) => runtimePackageVersion(value) !== void 0, {
   message: runtimePackageMessage
 }), rootThemeSchema = z4.object({
   defaultMode: z4.enum(["system", "light", "dark"]).optional(),
   forcedMode: z4.enum(["light", "dark"]).optional()
-}).strict(), remoteMediaSourceSchema = z4.object({
-  protocol: z4.literal("https"),
-  hostname: z4.string().min(1),
-  pathname: z4.string().optional()
-}).strict(), remoteEmbedSourceSchema = z4.object({
-  provider: z4.enum([
-    "youtube",
-    "vimeo",
-    "loom",
-    "wistia",
-    "cloudflare-stream"
-  ]),
-  hostname: z4.string().min(1)
 }).strict(), mediaConfigSchema = z4.object({
-  assets: z4.object({
-    maxImageBytes: z4.number().int().positive().optional(),
-    maxVideoBytes: z4.number().int().positive().optional(),
-    maxTotalBytes: z4.number().int().positive().optional(),
-    maxFileCount: z4.number().int().positive().optional()
-  }).strict().optional(),
-  remote: z4.object({
-    images: z4.array(remoteMediaSourceSchema).optional(),
-    videos: z4.array(remoteMediaSourceSchema).optional(),
-    embeds: z4.array(remoteEmbedSourceSchema).optional()
-  }).strict().optional()
+  assets: z4.object({}).strict().optional()
 }).strict(), agentConfigSchema = z4.object({
   enabled: z4.boolean().optional(),
   markdownRoutes: z4.boolean().optional(),
   markdownAccept: z4.boolean().optional(),
-  plainTextAccept: z4.boolean().optional(),
   agentDetection: z4.boolean().optional(),
   discoveryHeaders: z4.boolean().optional(),
   blockInternalMarkdownRoute: z4.boolean().optional()
@@ -310,11 +358,11 @@ var siteSchema = z4.object({
   theme: rootThemeSchema.optional(),
   fonts: fontConfigSchema.optional(),
   media: mediaConfigSchema.optional(),
-  og: ogIndexMetadataSchema.optional(),
-  meta: z4.record(z4.unknown()).optional(),
+  metadata: indexMetadataSchema.optional(),
+  meta: z4.record(z4.string(), z4.unknown()).optional(),
   outputs: outputsSchema.optional(),
   outputDefaults: outputDefaultsSchema.optional(),
-  groups: z4.record(groupConfigDocumentSchema).default({})
+  groups: z4.record(z4.string(), groupConfigDocumentSchema).default({})
 }).strict();
 
 // src/lib/compiler/source/diagnostics/json-source-location.ts
@@ -603,9 +651,17 @@ async function discoverGroups(options) {
           parent: options.parentKey
         }
       });
-    if (siblingKeys.set(normalized.localKey, entry.name), !await isDiscoverableGroupFolder(folderPath, options.absoluteBase))
-      continue;
-    let key = options.parentKey ? `${options.parentKey}/${normalized.localKey}` : normalized.localKey, group = {
+    siblingKeys.set(normalized.localKey, entry.name);
+    let key = options.parentKey ? `${options.parentKey}/${normalized.localKey}` : normalized.localKey, isDiscoverable = await isDiscoverableGroupFolder(
+      folderPath,
+      options.absoluteBase
+    ), children = await discoverGroups({
+      absoluteBase: options.absoluteBase,
+      folderPath,
+      parentKey: key
+    });
+    if (!isDiscoverable && children.length === 0) continue;
+    let group = {
       key,
       localKey: normalized.localKey,
       localFolderName: entry.name,
@@ -614,13 +670,7 @@ async function discoverGroups(options) {
       layoutBoundary: normalized.layoutBoundary,
       hasContent: await pathIsDirectory(join(folderPath, "content"))
     };
-    groups.push(group), groups.push(
-      ...await discoverGroups({
-        absoluteBase: options.absoluteBase,
-        folderPath,
-        parentKey: key
-      })
-    );
+    groups.push(group, ...children);
   }
   return groups;
 }
@@ -720,7 +770,20 @@ async function collectGroup(options) {
     localConfigPath,
     key,
     absoluteBase
-  ), merged = mergeGroupConfig(entry, localConfig), slug = normalizeGroupSlug(merged.slug ?? localKey, key), path = merged.path ? normalizeGroupPath(merged.path, key) : joinUrlPath(parentPath, slug), contentPath = join(folderPath, "content");
+  ), merged = mergeGroupConfig(entry, localConfig), slug = normalizeGroupSlug(merged.slug ?? localKey, key), path = merged.path ? normalizeGroupPath(merged.path, key) : joinUrlPath(parentPath, slug);
+  if (parentKey && (parentPath === "/" ? path === "/" : path === parentPath || !path.startsWith(`${parentPath}/`)))
+    throw new AppError2({
+      code: ERROR_CODES.CONFIG_GROUP_INVALID_SCHEMA,
+      message: `Nested group ${key} must use a path beneath its parent ${parentKey} (${parentPath}); received ${path}`,
+      details: {
+        group: key,
+        parentGroup: parentKey,
+        path,
+        parentPath,
+        correction: `Set the path for ${key} to a path beneath ${parentPath}, or move the group to a top-level source folder.`
+      }
+    });
+  let contentPath = join(folderPath, "content");
   discovered.hasContent && await ensureDirectoryExists(contentPath, key, "content folder");
   let existingPathOwner = paths.get(path);
   if (existingPathOwner && !(path === "/" && existingPathOwner === ROOT_CONTENT_GROUP_KEY))
@@ -731,6 +794,7 @@ async function collectGroup(options) {
     });
   paths.set(path, key), groups[key] = {
     ...merged,
+    ...localConfig?.navigation ? { localNavigation: localConfig.navigation } : {},
     key,
     slug,
     path,
@@ -801,25 +865,55 @@ async function resolvePublishOsConfig(baseDir) {
 
 // src/lib/compiler/source/content/scan-publish-os-content.ts
 import { readdir as readdir2, readFile as readFile3, stat as stat2 } from "fs/promises";
-import { extname, join as join2, relative as relative2 } from "path";
-import matter from "gray-matter";
-var RESERVED_FIELDS = /* @__PURE__ */ new Set([
-  "title",
-  "slug",
-  "description",
-  "og",
-  "status",
-  "publishedAt",
-  "updatedAt",
-  "authors",
-  "tags"
-]), UNSUPPORTED_FIELDS = /* @__PURE__ */ new Set(["author", "meta", "metadata"]);
+import { extname as extname2, join as join2, relative as relative2 } from "path";
+
+// src/lib/compiler/source/content/page-defaults.ts
+import { basename, extname } from "path";
+import remarkMdx from "remark-mdx";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+var parser = unified().use(remarkParse).use(remarkMdx);
+function defaultTitle(path) {
+  return basename(path, extname(path)).replace(/[-_]+/g, " ").replace(
+    /(^|\s)(\p{L})/gu,
+    (_, space, letter) => space + letter.toLocaleUpperCase()
+  );
+}
+function staticText(node) {
+  return node.type === "text" ? node.value ?? "" : ["emphasis", "strong", "delete", "link", "linkReference"].includes(
+    node.type
+  ) ? (node.children ?? []).map((child) => staticText(child)).join("") : "";
+}
+function firstProse(node) {
+  if (node.type === "paragraph")
+    return (node.children ?? []).map((child) => staticText(child)).join("").replace(/\s+/g, " ").trim() || void 0;
+  if (["root", "blockquote", "list", "listItem"].includes(node.type))
+    for (let child of node.children ?? []) {
+      let prose = firstProse(child);
+      if (prose) return prose;
+    }
+}
+function defaultDescription(body) {
+  let prose = firstProse(parser.parse(body));
+  if (!prose) return "";
+  let sentence = [
+    ...new Intl.Segmenter(void 0, { granularity: "sentence" }).segment(
+      prose
+    )
+  ][0]?.segment.trim() ?? prose, chars = [
+    ...new Intl.Segmenter(void 0, { granularity: "grapheme" }).segment(
+      sentence
+    )
+  ].map(({ segment }) => segment);
+  if (chars.length <= 160) return sentence;
+  let prefix = chars.slice(0, 159).join(""), boundary = /\s/u.test(chars[159] ?? "") ? -1 : prefix.search(/\s+\S*$/u);
+  return `${(boundary > 0 ? prefix.slice(0, boundary) : prefix).trimEnd()}\u2026`;
+}
+
+// src/lib/compiler/source/content/scan-publish-os-content.ts
 function fileSlug(relativePath) {
   return relativePath.replace(/\\/g, "/").replace(/\.mdx$/i, "");
 }
-function asString(value) {
-  return typeof value == "string" && value.length > 0 ? value : void 0;
-}
 function normalizeContentSlug(value, absolutePath) {
   let result = normalizeSlugPath(value);
   if (result.errors.length > 0)
@@ -834,283 +928,153 @@ function normalizeContentSlug(value, absolutePath) {
     });
   return result.value;
 }
-function asDateString(value) {
-  if (typeof value == "string" && value.length > 0) return value;
-  if (value instanceof Date && !Number.isNaN(value.getTime()))
-    return value.toISOString().slice(0, 10);
-}
-function isIsoDate(value) {
-  return !Number.isNaN(Date.parse(value));
-}
 function warning(code, message, details) {
   return { code, level: "warning", message, details };
 }
-function treeSlugs(nodes) {
-  function visit(tree) {
-    let slugs = /* @__PURE__ */ new Map();
-    for (let node of tree)
-      if (node.type === "page" && (slugs.has(node.file) || slugs.set(node.file, asString(node.slug))), "children" in node && node.children)
-        for (let [fileID, slug] of visit(node.children))
-          slug && !slugs.has(fileID) && slugs.set(fileID, slug);
-    return slugs;
-  }
-  return visit(nodes ?? []);
-}
-function normalizeAuthorship(authors, absolutePath) {
-  let warnings = [];
-  if (authors === void 0)
-    return { authors: [], warnings };
-  if (!Array.isArray(authors))
-    return warnings.push(
-      warning(
-        "CONTENT_AUTHORS_INVALID",
-        `Ignoring invalid authors for ${absolutePath}`,
-        {
-          path: absolutePath
-        }
-      )
-    ), { authors: [], warnings };
-  let normalized = [];
-  for (let author of authors) {
-    if (typeof author == "string" && author.length > 0) {
-      normalized.push({ name: author });
-      continue;
-    }
-    if (author && typeof author == "object" && typeof author.name == "string") {
-      let value = author;
-      normalized.push({
-        id: asString(value.id),
-        name: value.name,
-        handle: asString(value.handle),
-        avatar: asString(value.avatar),
-        url: asString(value.url)
-      });
-      continue;
-    }
-    warnings.push(
-      warning(
-        "CONTENT_AUTHOR_INVALID",
-        `Ignoring invalid author entry for ${absolutePath}`,
-        {
-          path: absolutePath
-        }
-      )
-    );
-  }
-  return { authors: normalized, warnings };
-}
-function normalizeTags(tags, absolutePath) {
-  return tags === void 0 ? { tags: [], warnings: [] } : Array.isArray(tags) ? {
-    tags: tags.filter((tag) => typeof tag == "string"),
-    warnings: []
-  } : {
-    tags: [],
-    warnings: [
-      warning(
-        "CONTENT_TAGS_INVALID",
-        `Ignoring invalid tags for ${absolutePath}`,
-        {
-          path: absolutePath
-        }
-      )
-    ]
-  };
-}
-function normalizeOgMetadata(value, absolutePath) {
-  if (value === void 0) return;
-  if (!value || typeof value != "object" || Array.isArray(value))
-    throw new AppError2({
-      code: "CONTENT_FRONTMATTER_OG_INVALID",
-      message: `Invalid og frontmatter for ${absolutePath}; expected an object with title, description, or image`,
-      details: { path: absolutePath, field: "og" }
-    });
-  let source = value, allowedFields = /* @__PURE__ */ new Set(["title", "description", "image"]);
-  for (let field of Object.keys(source))
-    if (!allowedFields.has(field))
-      throw new AppError2({
-        code: "CONTENT_FRONTMATTER_OG_INVALID",
-        message: `Invalid og frontmatter field "${field}" for ${absolutePath}`,
-        details: { path: absolutePath, field: `og.${field}` }
-      });
-  let og = {};
-  if (source.title !== void 0) {
-    if (typeof source.title != "string" || source.title.length === 0)
-      throw new AppError2({
-        code: "CONTENT_FRONTMATTER_OG_INVALID",
-        message: `Invalid og.title for ${absolutePath}; expected a non-empty string`,
-        details: { path: absolutePath, field: "og.title" }
-      });
-    og.title = source.title;
-  }
-  if (source.description !== void 0) {
-    if (typeof source.description != "string" || source.description.length === 0)
-      throw new AppError2({
-        code: "CONTENT_FRONTMATTER_OG_INVALID",
-        message: `Invalid og.description for ${absolutePath}; expected a non-empty string`,
-        details: { path: absolutePath, field: "og.description" }
-      });
-    og.description = source.description;
-  }
-  if (source.image !== void 0)
-    if (typeof source.image == "string" && source.image.length > 0)
-      og.image = source.image;
-    else if (source.image && typeof source.image == "object" && !Array.isArray(source.image)) {
-      let image = source.image, allowedImageFields = /* @__PURE__ */ new Set(["src", "alt"]);
-      for (let field of Object.keys(image))
-        if (!allowedImageFields.has(field))
-          throw new AppError2({
-            code: "CONTENT_FRONTMATTER_OG_INVALID",
-            message: `Invalid og.image field "${field}" for ${absolutePath}`,
-            details: { path: absolutePath, field: `og.image.${field}` }
-          });
-      if (typeof image.src != "string" || image.src.length === 0)
-        throw new AppError2({
-          code: "CONTENT_FRONTMATTER_OG_INVALID",
-          message: `Invalid og.image.src for ${absolutePath}; expected a non-empty string`,
-          details: { path: absolutePath, field: "og.image.src" }
-        });
-      if (image.alt !== void 0 && typeof image.alt != "string")
-        throw new AppError2({
-          code: "CONTENT_FRONTMATTER_OG_INVALID",
-          message: `Invalid og.image.alt for ${absolutePath}; expected a string`,
-          details: { path: absolutePath, field: "og.image.alt" }
-        });
-      og.image = {
-        src: image.src,
-        ...typeof image.alt == "string" ? { alt: image.alt } : {}
-      };
-    } else
-      throw new AppError2({
-        code: "CONTENT_FRONTMATTER_OG_INVALID",
-        message: `Invalid og.image for ${absolutePath}; expected a non-empty string or object with src`,
-        details: { path: absolutePath, field: "og.image" }
-      });
-  return Object.keys(og).length > 0 ? og : void 0;
-}
-function customMeta(frontmatter, absolutePath) {
-  let meta = {}, warnings = [];
-  for (let [key, value] of Object.entries(frontmatter))
-    if (!RESERVED_FIELDS.has(key)) {
-      if (UNSUPPORTED_FIELDS.has(key)) {
+async function readContentFile(group, absolutePath) {
+  let raw = await readFile3(absolutePath, "utf-8");
+  try {
+    let parsed = parseSourceFrontmatter(raw), frontmatter = parsed.data, relativePath = relative2(group.contentPath, absolutePath), fileID = normalizeContentSlug(fileSlug(relativePath), absolutePath), warnings = [];
+    if (parsed.content.includes("<")) {
+      let unknown = new Set(
+        convertMdxToMarkdown({ source: parsed.content }).diagnostics.filter(
+          (diagnostic) => diagnostic.code === "mdx-component-unknown"
+        ).map((diagnostic) => diagnostic.componentName).filter((name) => !!name)
+      );
+      for (let name of unknown)
         warnings.push(
           warning(
-            "CONTENT_FRONTMATTER_FIELD_UNSUPPORTED",
-            `Ignoring unsupported frontmatter field "${key}" for ${absolutePath}`,
-            { path: absolutePath, field: key }
+            "CONTENT_COMPONENT_NOT_CONVERTED",
+            `Custom component <${name}> renders in HTML, but its runtime output is not included in generated Markdown or search. Authored children remain available.`,
+            { path: absolutePath }
           )
         );
-        continue;
-      }
-      meta[key] = value;
     }
-  return { meta, warnings };
-}
-async function readContentFile(group, absolutePath, configSlugs) {
-  let raw = await readFile3(absolutePath, "utf-8");
-  try {
-    let parsed = matter(raw), frontmatter = parsed.data, relativePath = relative2(group.contentPath, absolutePath), fileID = normalizeContentSlug(fileSlug(relativePath), absolutePath), title = asString(frontmatter.title);
-    if (frontmatter.id !== void 0)
-      throw new AppError2({
-        code: ERROR_CODES.CONTENT_FRONTMATTER_ID_INVALID,
-        message: `Frontmatter field "id" is not supported for ${absolutePath}; page identity is derived from fileID`,
-        details: { path: absolutePath, field: "id" }
-      });
+    for (let field of ["title", "description"])
+      if (frontmatter[field] !== void 0 && typeof frontmatter[field] != "string")
+        throw new AppError2({
+          code: "CONTENT_FRONTMATTER_TYPE_INVALID",
+          message: `Invalid frontmatter field "${field}" in ${absolutePath}; expected a string. Remove it to use the default or provide text.`,
+          details: { path: absolutePath, field }
+        });
+    let title = frontmatter.title?.trim() || defaultTitle(relativePath), description = frontmatter.description?.trim() || defaultDescription(parsed.content);
+    for (let field of ["title", "description"])
+      frontmatter[field]?.trim() || warnings.push(
+        warning(
+          "CONTENT_FRONTMATTER_DEFAULT",
+          `Missing or blank ${field} in ${absolutePath}; add ${field} to frontmatter.`,
+          { path: absolutePath, field }
+        )
+      );
     if (!fileID)
       throw new AppError2({
         code: ERROR_CODES.CONTENT_FRONTMATTER_ID_INVALID,
         message: `Could not derive fileID for ${absolutePath}`,
         details: { path: absolutePath }
       });
-    if (!title)
+    if (frontmatter.slug !== void 0 && (typeof frontmatter.slug != "string" || !frontmatter.slug.trim() || /[\\/]/.test(frontmatter.slug)))
       throw new AppError2({
-        code: ERROR_CODES.CONTENT_FRONTMATTER_REQUIRED,
-        message: `Missing required frontmatter field "title" for ${absolutePath}`,
-        details: { path: absolutePath, field: "title" }
+        code: ERROR_CODES.CONTENT_SLUG_INVALID,
+        message: `Invalid slug in ${absolutePath}; use one nonempty path segment, or remove slug to use the filename.`,
+        details: {
+          path: absolutePath,
+          field: "slug",
+          correction: "Remove slug or provide one nonempty path segment."
+        }
       });
-    let warnings = [], frontmatterSlug = asString(frontmatter.slug), slugSource = configSlugs.get(fileID) ?? frontmatterSlug ?? fileID, slugResult = normalizeSlugPath(slugSource);
-    if (slugResult.errors.length > 0)
+    let sourceSegments = fileID.split("/"), slugSource = frontmatter.slug ?? sourceSegments.at(-1) ?? "", slugResult = normalizeSlugPath(slugSource);
+    if (slugResult.errors.length > 0 || !slugResult.value || slugResult.value.includes("/"))
       throw new AppError2({
         code: ERROR_CODES.CONTENT_SLUG_INVALID,
-        message: `Invalid content slug "${slugSource}" for ${absolutePath}`,
+        message: `Invalid slug "${slugSource}" in ${absolutePath}; remove it or provide one valid path segment.`,
         details: {
           errors: slugResult.errors,
           path: absolutePath,
-          slug: slugSource
+          field: "slug",
+          correction: "Remove slug or provide one valid path segment."
         }
       });
-    let slug = slugResult.value;
-    slugResult.changed && warnings.push(
+    let slug = slugResult.value, routeSlug = [...sourceSegments.slice(0, -1), slug].join("/");
+    if (slugResult.changed && warnings.push(
       warning(
         "CONTENT_SLUG_NORMALIZED",
         `Normalized slug "${slugSource}" to "${slug}" for ${absolutePath}`,
         { path: absolutePath, from: slugSource, to: slug }
       )
-    );
-    let status = "published";
-    frontmatter.status === "published" || frontmatter.status === "draft" || frontmatter.status === "archived" ? status = frontmatter.status : frontmatter.status !== void 0 && warnings.push(
+    ), frontmatter.status !== void 0 && typeof frontmatter.status != "string")
+      throw new AppError2({
+        code: "CONTENT_FRONTMATTER_TYPE_INVALID",
+        message: `Invalid frontmatter field "status" in ${absolutePath}; expected a string.`,
+        details: {
+          path: absolutePath,
+          field: "status",
+          correction: 'Set status to "draft" or "published", or remove it.'
+        }
+      });
+    let normalizedStatus = frontmatter.status?.trim().toLowerCase(), status = "published";
+    normalizedStatus === "published" || normalizedStatus === "draft" ? status = normalizedStatus : frontmatter.status !== void 0 && warnings.push(
       warning(
         "CONTENT_STATUS_INVALID",
-        `Invalid status "${String(frontmatter.status)}" for ${absolutePath}; defaulting to published`,
-        { path: absolutePath, status: frontmatter.status }
-      )
-    );
-    let rawPublishedAt = asDateString(frontmatter.publishedAt), publishedAt = rawPublishedAt && isIsoDate(rawPublishedAt) ? rawPublishedAt : void 0;
-    rawPublishedAt && !publishedAt && warnings.push(
-      warning(
-        "CONTENT_DATE_INVALID",
-        `Invalid publishedAt for ${absolutePath}`,
+        `Status "${String(frontmatter.status)}" is not recognized; this page will be published.`,
         {
           path: absolutePath,
-          field: "publishedAt",
-          value: rawPublishedAt
+          propertyPath: "status",
+          correction: 'Set status to "draft" to keep the page unpublished, or "published" to publish it.'
         }
       )
     );
-    let rawUpdatedAt = asDateString(frontmatter.updatedAt), updatedAt = rawUpdatedAt && isIsoDate(rawUpdatedAt) ? rawUpdatedAt : void 0;
-    rawUpdatedAt && !updatedAt && warnings.push(
-      warning(
-        "CONTENT_DATE_INVALID",
-        `Invalid updatedAt for ${absolutePath}`,
-        {
+    let metadataResult = pageMetadataSchema.safeParse(
+      frontmatter.metadata === void 0 ? {} : frontmatter.metadata
+    );
+    if (!metadataResult.success) {
+      let issue = metadataResult.error.issues[0], key = issue?.code === "unrecognized_keys" ? issue.keys[0] : void 0, field = [
+        "metadata",
+        ...issue?.path ?? [],
+        ...key ? [key] : []
+      ].join(".");
+      throw new AppError2({
+        code: "CONTENT_FRONTMATTER_TYPE_INVALID",
+        message: `Invalid ${field} in ${absolutePath}. ${formatConfigIssues(metadataResult.error)}. Correct or remove this field.`,
+        details: {
           path: absolutePath,
-          field: "updatedAt",
-          value: rawUpdatedAt
+          field,
+          correction: `Correct or remove ${field}.`
         }
-      )
-    );
-    let authors = normalizeAuthorship(frontmatter.authors, absolutePath);
-    warnings.push(...authors.warnings);
-    let tags = normalizeTags(frontmatter.tags, absolutePath);
-    warnings.push(...tags.warnings);
-    let og = normalizeOgMetadata(frontmatter.og, absolutePath), meta = customMeta(frontmatter, absolutePath);
-    return warnings.push(...meta.warnings), {
+      });
+    }
+    let resolved = {
+      ...frontmatter,
+      title,
+      description,
+      slug,
+      status,
+      metadata: metadataResult.data
+    };
+    return {
       fileID,
       group: group.key,
-      slug,
-      title,
-      description: asString(frontmatter.description),
-      og,
+      slug: routeSlug,
+      frontmatter: resolved,
       status,
-      publishedAt,
-      updatedAt,
-      authors: authors.authors,
-      tags: tags.tags,
-      meta: meta.meta,
       absolutePath,
       relativePath,
-      body: parsed.content.trim(),
+      body: parsed.content,
       warnings
     };
   } catch (error) {
     throw error instanceof AppError2 ? error : new AppError2({
       code: ERROR_CODES.CONTENT_FILE_PARSE_FAILED,
-      message: `Failed to parse frontmatter for ${absolutePath}`,
-      details: { error }
+      message: `Failed to parse page ${absolutePath}: ${error instanceof Error ? error.message : String(error)}`,
+      details: {
+        path: absolutePath,
+        ...error instanceof FrontmatterParseError ? { line: error.line, column: error.column, field: error.field } : {},
+        error
+      }
     });
   }
 }
 async function walkContent(group) {
-  let files = [], stack = [group.contentPath], configSlugs = treeSlugs(group.tree);
+  let files = [], stack = [group.contentPath];
   for (; stack.length > 0; ) {
     let current = stack.pop();
     if (!current) continue;
@@ -1128,15 +1092,15 @@ async function walkContent(group) {
         stack.push(absolute);
         continue;
       }
-      extname(entry).toLowerCase() === ".mdx" && files.push(await readContentFile(group, absolute, configSlugs));
+      extname2(entry).toLowerCase() === ".mdx" && files.push(await readContentFile(group, absolute));
     }
   }
   return files;
 }
-function buildRoutes(groups, files) {
+function buildRoutes(groups, files, includeDrafts = !1) {
   let routes = [];
   for (let file of files) {
-    if (file.status === "draft")
+    if (file.status === "draft" && !includeDrafts)
       continue;
     let group = groups[file.group];
     if (!group)
@@ -1154,50 +1118,75 @@ function buildRoutes(groups, files) {
 async function scanContent(config) {
   let files = (await Promise.all(
     Object.values(config.groups).map((group) => walkContent(group))
-  )).flat(), warnings = files.flatMap((file) => file.warnings), fileIDs = /* @__PURE__ */ new Set();
+  )).flat(), warnings = files.flatMap((file) => file.warnings), fileIDs = /* @__PURE__ */ new Map();
   for (let file of files) {
-    let scopedFileID = `${file.group}:${file.fileID}`;
-    if (fileIDs.has(scopedFileID))
+    let scopedFileID = `${file.group}:${file.fileID}`, previous = fileIDs.get(scopedFileID), sourceRoot = config.groups[file.group]?.__meta.basePath ?? "";
+    if (previous)
       throw new AppError2({
         code: ERROR_CODES.CONTENT_DUPLICATE_ID,
-        message: `Duplicate content fileID "${file.fileID}" in group ${file.group}`,
-        details: { fileID: file.fileID, group: file.group }
+        message: `Duplicate page identity "${file.fileID}" in group "${file.group}": ${relative2(sourceRoot, previous.absolutePath)} and ${relative2(sourceRoot, file.absolutePath)}. Rename one source file.`,
+        details: {
+          path: file.absolutePath,
+          existingPath: previous.absolutePath,
+          fileID: file.fileID,
+          group: file.group,
+          correction: "Rename one source file."
+        }
       });
-    fileIDs.add(scopedFileID);
+    fileIDs.set(scopedFileID, file);
   }
-  let routes = buildRoutes(config.groups, files), routePaths = /* @__PURE__ */ new Set(), groupPaths = new Map(
-    Object.values(config.groups).map((group) => [group.path, group.key])
-  );
-  for (let route of routes) {
-    if (routePaths.has(route.path))
-      throw new AppError2({
-        code: ERROR_CODES.CONTENT_DUPLICATE_ROUTE,
-        message: `Duplicate route "${route.path}"`,
-        details: { route: route.path }
-      });
-    let groupPathOwner = groupPaths.get(route.path);
-    if (groupPathOwner)
+  let candidates = buildRoutes(config.groups, files, !0), routes = buildRoutes(config.groups, files), owners = /* @__PURE__ */ new Map();
+  for (let group of Object.values(config.groups))
+    owners.set(group.path, {
+      source: relative2(
+        group.__meta.basePath,
+        group.__meta.filePath ?? group.__meta.basePath
+      ),
+      kind: `group ${group.key}`
+    });
+  for (let route of candidates) {
+    let file = fileIDs.get(`${route.group}:${route.fileID}`);
+    if (!file) continue;
+    let sourceRoot = config.groups[route.group]?.__meta.basePath ?? "", sourcePath = relative2(sourceRoot, file.absolutePath), paths = [[route.path, "page"]];
+    config.agent?.enabled !== !1 && config.agent?.markdownRoutes !== !1 && paths.push([`${route.path}.md`, "Markdown"]);
+    let normalized = normalizeSlugPath(route.path.replace(/^\//, ""));
+    if (normalized.errors.length)
       throw new AppError2({
-        code: ERROR_CODES.CONTENT_DUPLICATE_ROUTE,
-        message: `Content route "${route.path}" collides with group "${groupPathOwner}"`,
+        code: ERROR_CODES.CONTENT_SLUG_INVALID,
+        message: `Invalid route "${route.path}" for ${file.absolutePath}. Shorten the path.`,
         details: {
+          path: file.absolutePath,
           route: route.path,
-          group: route.group,
-          fileID: route.fileID,
-          existingGroup: groupPathOwner
+          errors: normalized.errors,
+          correction: "Shorten the path."
         }
       });
-    routePaths.add(route.path);
+    for (let [path, kind] of paths) {
+      let previous = owners.get(path);
+      if (previous)
+        throw new AppError2({
+          code: ERROR_CODES.CONTENT_DUPLICATE_ROUTE,
+          message: `URL "${path}" is used by ${previous.kind} ${previous.source} and ${kind} ${sourcePath}. Change a page slug or group path.`,
+          details: {
+            path: file.absolutePath,
+            existingPath: previous.source,
+            route: path,
+            correction: "Change a page slug or group path."
+          }
+        });
+      owners.set(path, { source: sourcePath, kind });
+    }
   }
   let meta = config.meta;
   return {
     site: {
       name: config.site?.name ?? meta?.title ?? "Untitled",
       description: config.site?.description ?? meta?.description,
-      ...config.og ? { og: config.og } : {}
+      ...config.metadata ? { metadata: config.metadata } : {}
     },
     files,
     routes,
+    candidateRoutes: candidates,
     warnings
   };
 }
@@ -1216,13 +1205,26 @@ function appErrorToDiagnostic(error) {
 import { readFile as readFile4 } from "fs/promises";
 import { relative as relative3, resolve as resolve4 } from "path";
 async function missingPageReferences(options) {
-  let diagnostics = [], configSource = /* @__PURE__ */ new Map(), routes = new Set(
-    options.content.routes.map((route) => `${route.group}\0${route.fileID}`)
+  let diagnostics = [], configSource = /* @__PURE__ */ new Map(), files = new Map(
+    options.content.files.map(
+      (file) => [
+        relative3(options.sourceRoot, file.absolutePath).replace(/\\/g, "/"),
+        file
+      ]
+    )
+  ), groupContentRoots = Object.values(options.config.groups).map(
+    (group) => ({
+      group,
+      prefix: `${group.__meta.relativeContentPath.replace(/\\/g, "/")}/`
+    })
   ), rootConfig = resolve4(options.sourceRoot, "publish.os.config.json");
-  async function locationFor(groupKey, groupFile, path) {
+  function groupForSourcePath(path) {
+    return groupContentRoots.filter(({ prefix }) => path.startsWith(prefix)).sort((a, b) => b.prefix.length - a.prefix.length)[0]?.group;
+  }
+  async function locationFor(groupFile, path, rootPath) {
     for (let [file, sourcePath] of [
       [groupFile, path],
-      [rootConfig, ["groups", groupKey, ...path]]
+      [rootConfig, rootPath]
     ]) {
       let raw = configSource.get(file);
       raw === void 0 && (raw = await readFile4(file, "utf8"), configSource.set(file, raw));
@@ -1235,227 +1237,491 @@ async function missingPageReferences(options) {
     }
   }
   for (let group of Object.values(options.config.groups)) {
-    async function visit(nodes, path) {
+    let hasLocalNavigation = !!group.localNavigation, basePath = hasLocalNavigation ? ["navigation", "items"] : ["groups", group.key, "navigation", "items"], rootBasePath = hasLocalNavigation ? ["groups", group.key, ...basePath] : basePath;
+    async function visit(nodes, path, rootPath, contentGroup = group) {
       for (let [index, node] of nodes.entries()) {
-        let nodePath = [...path, index];
-        if (node.type === "page" && !routes.has(`${group.key}\0${node.file}`)) {
-          let propertyPath = `groups.${group.key}.${nodePath.join(".")}.file`, location = await locationFor(group.key, group.__meta.filePath, [
-            ...nodePath,
-            "file"
-          ]), expected = `publish.os/${group.__meta.relativeContentPath.replace(/\\/g, "/")}/${node.file}.mdx`;
-          diagnostics.push({
-            code: "CONTENT_TREE_PAGE_MISSING",
-            level: "warning",
-            message: `Referenced page "${node.file}" was not found. Expected ${expected}.`,
-            details: {
-              ...location,
-              propertyPath,
-              correction: "Add that page, or change or remove the tree entry."
-            }
-          });
+        let nodePath = [...path, index], rootNodePath = [...rootPath, index], targetGroupKey = node.type === "folder" || node.type === "page" ? node.group : void 0, nestedContentGroup = targetGroupKey ? options.config.groups[targetGroupKey] ?? contentGroup : contentGroup;
+        if (node.type === "page" && node.file) {
+          let expected = node.file.replace(/\\/g, "/"), propertyPath = `${nodePath.join(".")}.file`, location = await locationFor(
+            group.__meta.filePath,
+            [...nodePath, "file"],
+            [...rootNodePath, "file"]
+          ), expectedPrefix = `${contentGroup.__meta.relativeContentPath.replace(/\\/g, "/")}/`, referencedFile = files.get(expected), targetGroupKey2 = (referencedFile ? options.config.groups[referencedFile.group] : groupForSourcePath(expected))?.key ?? referencedFile?.group, isForeign = targetGroupKey2 !== void 0 && targetGroupKey2 !== contentGroup.key;
+          if (isForeign || !referencedFile) {
+            let code = isForeign ? "NAVIGATION_PAGE_FOREIGN" : "NAVIGATION_PAGE_MISSING", message = isForeign ? `Referenced page "${node.file}" belongs to group "${targetGroupKey2}", not "${contentGroup.key}".` : `Referenced page "${node.file}" was not found.`;
+            diagnostics.push({
+              code,
+              level: "error",
+              message,
+              details: {
+                ...location,
+                propertyPath,
+                group: contentGroup.key,
+                target: node.file,
+                ...targetGroupKey2 ? { owner: targetGroupKey2 } : {},
+                correction: `Use a source-root-relative MDX path inside ${expectedPrefix}, such as ${expectedPrefix}<file>.mdx.`
+              }
+            });
+          }
         }
-        "children" in node && node.children && await visit(node.children, [...nodePath, "children"]);
+        "items" in node && node.items && await visit(
+          node.items,
+          [...nodePath, "items"],
+          [...rootNodePath, "items"],
+          nestedContentGroup
+        ), (node.type === "folder" || node.type === "page") && node.navigation && await visit(
+          node.navigation.items,
+          [...nodePath, "navigation", "items"],
+          [...rootNodePath, "navigation", "items"],
+          nestedContentGroup
+        );
       }
     }
-    await visit(group.tree ?? [], ["tree"]);
+    let navigation = group.localNavigation ?? group.navigation;
+    await visit(navigation?.items ?? [], basePath, rootBasePath);
   }
   return diagnostics;
 }
 
 // src/lib/compiler/source/manifest/create-publish-os-manifest.ts
 import { createHash } from "crypto";
+
+// src/lib/compiler/source/manifest/sort-navigation-entries.ts
+function sortKey(value, type) {
+  if (value === void 0) return { reason: "missing" };
+  if (type === "number")
+    return typeof value == "number" && Number.isFinite(value) ? { value } : { reason: "invalid" };
+  let date = authoredDate(value);
+  return date ? { value: Date.parse(date) } : { reason: "invalid" };
+}
+function filenameOrder(left, right) {
+  return left.localeCompare(right);
+}
+function sortNavigationEntries({
+  entries,
+  explicitCount = 0,
+  field,
+  type,
+  direction
+}) {
+  if (!Number.isInteger(explicitCount) || explicitCount < 0 || explicitCount > entries.length)
+    throw new RangeError(
+      "explicitCount must be between zero and the entry count."
+    );
+  let automatic = entries.slice(explicitCount), pageEntries = automatic.flatMap(
+    (candidate, index) => candidate.kind === "page" ? [{ candidate, index, key: sortKey(candidate.frontmatter[field], type) }] : []
+  ), warnings = pageEntries.flatMap(
+    ({ candidate, key }) => key.reason ? [
+      {
+        code: key.reason === "missing" ? "NAVIGATION_SORT_VALUE_MISSING" : "NAVIGATION_SORT_VALUE_INVALID",
+        field,
+        file: candidate.sourcePath
+      }
+    ] : []
+  ), directionFactor = direction === "asc" ? 1 : -1;
+  pageEntries.sort((left, right) => {
+    let leftValue = left.key.value, rightValue = right.key.value, leftValid = leftValue !== void 0;
+    return leftValid !== (rightValue !== void 0) ? leftValid ? -1 : 1 : leftValue !== void 0 && rightValue !== void 0 && leftValue !== rightValue ? (leftValue - rightValue) * directionFactor : filenameOrder(
+      left.candidate.sourcePath,
+      right.candidate.sourcePath
+    ) || left.index - right.index;
+  });
+  let nextPage = 0, sortedAutomatic = automatic.map(
+    (candidate) => candidate.kind === "page" ? pageEntries[nextPage++]?.candidate : candidate
+  );
+  return {
+    entries: [
+      ...entries.slice(0, explicitCount).map((candidate) => candidate.entry),
+      ...sortedAutomatic.flatMap(
+        (candidate) => candidate ? [candidate.entry] : []
+      )
+    ],
+    warnings
+  };
+}
+
+// src/lib/compiler/source/manifest/create-publish-os-manifest.ts
 function stableStringify(value) {
   return Array.isArray(value) ? `[${value.map((item) => stableStringify(item)).join(",")}]` : value && typeof value == "object" ? `{${Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(
     ([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`
   ).join(",")}}` : JSON.stringify(value);
 }
-function resolveGroupReference(config, currentGroup, reference) {
-  let relativeKey = `${currentGroup}/${reference}`;
-  if (config.groups[relativeKey]) return relativeKey;
-  if (config.groups[reference]) return reference;
-}
-function normalizeTreeNode(node, group, pagesByFileID, routesByFileID, options) {
-  if (node.type === "page") {
-    let page = pagesByFileID.get(node.file), route = routesByFileID.get(node.file);
-    return !page || !route ? null : {
-      type: "page",
-      fileID: node.file,
-      title: node.title ?? page.title,
-      path: route.path,
-      group,
-      description: page.description,
-      og: page.og,
-      status: page.status,
-      publishedAt: page.publishedAt,
-      updatedAt: page.updatedAt,
-      authors: page.authors,
-      tags: page.tags,
-      meta: page.meta
-    };
-  }
-  if (node.type === "link")
-    return {
-      type: "link",
-      id: node.id,
-      title: node.title,
-      href: node.url
-    };
-  let children = node.children?.map(
-    (child) => normalizeTreeNode(child, group, pagesByFileID, routesByFileID, options)
-  ).filter((child) => child !== null) ?? [];
-  if (node.type === "folder") {
-    let referencedGroup = resolveGroupReference(
-      options.config,
-      group,
-      node.group ?? node.id
-    ), referencedChildren = children.length > 0 || !referencedGroup ? children : options.childTreeForGroup(referencedGroup);
-    return {
-      type: "folder",
-      id: node.id,
-      title: node.title,
-      path: referencedGroup ? options.config.groups[referencedGroup]?.path : void 0,
-      group: referencedGroup ?? group,
-      children: referencedChildren
-    };
-  }
-  return {
-    type: node.type,
-    id: node.id,
-    title: node.title,
-    group,
-    children
-  };
+function nodeId(group, source, type) {
+  return createHash("sha256").update(`${group}\0${type}\0${source}`).digest("hex").slice(0, 16);
 }
-function defaultTree(group, pages, routesByFileID) {
-  return pages.flatMap((page) => {
-    let route = routesByFileID.get(page.fileID);
-    return route ? {
-      type: "page",
-      fileID: page.fileID,
-      title: page.title,
-      path: route.path,
+function navigationError(message, group, target, source) {
+  return new AppError2({
+    code: ERROR_CODES.CONFIG_GROUP_INVALID_SCHEMA,
+    message,
+    details: {
       group,
-      description: page.description,
-      og: page.og,
-      status: page.status,
-      publishedAt: page.publishedAt,
-      updatedAt: page.updatedAt,
-      authors: page.authors,
-      tags: page.tags,
-      meta: page.meta
-    } : [];
-  }).sort((a, b) => a.path.localeCompare(b.path));
-}
-function configuredPageIds(nodes) {
-  let ids = /* @__PURE__ */ new Set();
-  for (let node of nodes ?? []) {
-    if (node.type === "page") {
-      ids.add(node.file);
-      continue;
+      target,
+      ...source ? { propertyPath: source } : {},
+      correction: "Correct the navigation entry and save the group config."
+    }
+  });
+}
+function defaultItems(options) {
+  let remaining = new Map(options.pages.map((page) => [page.fileID, page])), sortWarningReported = !1;
+  function folderItems(folder) {
+    let names = /* @__PURE__ */ new Set();
+    for (let fileID of remaining.keys()) {
+      if (folder && !fileID.startsWith(`${folder}/`)) continue;
+      let name = fileID.slice(folder ? folder.length + 1 : 0);
+      names.add(name.split("/")[0] ?? name);
+    }
+    let items2 = [];
+    for (let name of [...names].sort((a, b) => a.localeCompare(b))) {
+      let prefix = folder ? `${folder}/${name}` : name, file = remaining.get(prefix);
+      if (file) {
+        remaining.delete(prefix);
+        let route = options.routes.get(file.fileID);
+        if (!route) continue;
+        items2.push({
+          id: nodeId(options.group, file.fileID, "page"),
+          type: "page",
+          label: file.frontmatter.title,
+          href: route.path,
+          page: {
+            fileID: file.fileID,
+            group: file.group,
+            path: file.path,
+            frontmatter: file.frontmatter
+          }
+        });
+        continue;
+      }
+      let children = folderItems(prefix);
+      children.length && items2.push({
+        id: nodeId(options.group, prefix, "folder"),
+        type: "folder",
+        label: name,
+        children
+      });
     }
-    if ("children" in node)
-      for (let id of configuredPageIds(node.children))
-        ids.add(id);
+    return sortItems(items2);
+  }
+  let items = folderItems("");
+  for (let child of options.childGroups)
+    items.push(options.makeGroup(child, "page"));
+  return items;
+  function sortItems(items2) {
+    let sort = options.sort;
+    if (!sort)
+      return options.sortWarning && !sortWarningReported && (sortWarningReported = !0, options.onWarning?.({
+        code: "NAVIGATION_SORT_CONFIG_INVALID",
+        level: "warning",
+        message: `Group "${options.group}": ${options.sortWarning}`,
+        details: {
+          group: options.group,
+          propertyPath: "navigation.sort"
+        }
+      })), items2;
+    let result = sortNavigationEntries({
+      entries: items2.map(
+        (entry) => entry.type === "page" ? {
+          kind: "page",
+          entry,
+          sourcePath: `${options.contentPath.replace(/\\/g, "/")}/${entry.page.fileID}.mdx`,
+          frontmatter: entry.page.frontmatter
+        } : { kind: "other", entry }
+      ),
+      field: sort.field,
+      type: sort.type,
+      direction: sort.direction
+    });
+    for (let warning2 of result.warnings)
+      options.onWarning?.({
+        code: warning2.code,
+        level: "warning",
+        message: warning2.code === "NAVIGATION_SORT_VALUE_MISSING" ? `Navigation sort field "${warning2.field}" is missing from ${warning2.file}; the page sorts after valid values.` : `Navigation sort field "${warning2.field}" is invalid in ${warning2.file}; the page sorts after valid values.`,
+        details: {
+          group: options.group,
+          field: warning2.field,
+          file: warning2.file
+        }
+      });
+    return result.entries;
   }
-  return ids;
 }
-function createManifest(config, content) {
+function createManifest(config, content, onNavigationWarning) {
   let routesByGroup = /* @__PURE__ */ new Map();
   for (let route of content.routes) {
     let groupRoutes = routesByGroup.get(route.group);
     groupRoutes || (groupRoutes = /* @__PURE__ */ new Map(), routesByGroup.set(route.group, groupRoutes)), groupRoutes.has(route.fileID) || groupRoutes.set(route.fileID, route);
   }
-  let pages = [], pagesByGroup = /* @__PURE__ */ new Map(), pagesByFileIDByGroup = /* @__PURE__ */ new Map();
+  let pages = [], pagesByGroup = /* @__PURE__ */ new Map(), sourcePathToPage = /* @__PURE__ */ new Map();
   for (let file of content.files) {
     let route = routesByGroup.get(file.group)?.get(file.fileID);
     if (!route) continue;
     let page = {
       fileID: file.fileID,
       group: file.group,
-      slug: route.slug,
       path: route.path,
-      title: file.title,
-      description: file.description,
-      og: file.og,
-      status: file.status,
-      publishedAt: file.publishedAt,
-      updatedAt: file.updatedAt,
-      authors: file.authors,
-      tags: file.tags,
-      meta: file.meta,
+      frontmatter: file.frontmatter,
       body: file.body
     };
     pages.push(page);
     let groupPages = pagesByGroup.get(page.group);
     groupPages ? groupPages.push(page) : pagesByGroup.set(page.group, [page]);
-    let pagesByFileID = pagesByFileIDByGroup.get(page.group);
-    pagesByFileID || (pagesByFileID = /* @__PURE__ */ new Map(), pagesByFileIDByGroup.set(page.group, pagesByFileID)), pagesByFileID.has(page.fileID) || pagesByFileID.set(page.fileID, page);
+    let group = config.groups[file.group];
+    if (!group) continue;
+    let sourcePath = `${group.__meta.relativeContentPath.replace(/\\/g, "/")}/${file.relativePath.replace(/\\/g, "/")}`;
+    sourcePathToPage.set(sourcePath, page);
   }
-  let configuredPageIDsByGroup = /* @__PURE__ */ new Map();
-  for (let group of Object.values(config.groups))
-    configuredPageIDsByGroup.set(
-      group.key,
-      configuredPageIds(group.tree)
-    );
-  let treeCache = /* @__PURE__ */ new Map();
-  function groupTree(groupKey, stack = /* @__PURE__ */ new Set()) {
-    let cached = treeCache.get(groupKey);
-    if (cached) return cached;
-    if (stack.has(groupKey)) return [];
+  let groupEntries = Object.values(config.groups), childrenByGroup = /* @__PURE__ */ new Map();
+  for (let group of groupEntries) {
+    if (!group.parentKey) continue;
+    let children = childrenByGroup.get(group.parentKey) ?? [];
+    children.push(group.key), childrenByGroup.set(group.parentKey, children);
+  }
+  for (let children of childrenByGroup.values())
+    children.sort((a, b) => a.localeCompare(b));
+  function groupNode(groupKey, presentation, label, fallback, stack, placementPath) {
+    if (stack.has(groupKey))
+      throw navigationError(
+        `Recursive group placement for "${groupKey}".`,
+        groupKey,
+        groupKey
+      );
+    let group = config.groups[groupKey];
+    if (!group)
+      throw navigationError(
+        `Navigation references missing group "${groupKey}".`,
+        groupKey,
+        groupKey
+      );
+    let children = buildGroupItems(
+      groupKey,
+      group.localNavigation ?? fallback ?? group.navigation,
+      /* @__PURE__ */ new Set([...stack, groupKey]),
+      fallback
+    ), route = group.path;
+    return {
+      id: nodeId(groupKey, placementPath, "group"),
+      type: "group",
+      label: label ?? group.title ?? groupKey,
+      groupKey,
+      route,
+      presentation,
+      ...presentation === "page" ? { href: route } : {},
+      children
+    };
+  }
+  function buildGroupItems(groupKey, navigation, stack = /* @__PURE__ */ new Set(), inheritedFallback) {
     let group = config.groups[groupKey];
     if (!group) return [];
-    stack.add(groupKey);
-    let groupPages = pagesByGroup.get(group.key) ?? [], pagesByFileID = pagesByFileIDByGroup.get(group.key) ?? /* @__PURE__ */ new Map(), routesByFileID = routesByGroup.get(group.key) ?? /* @__PURE__ */ new Map(), configTree = group.tree, configuredPageIDs = configuredPageIDsByGroup.get(group.key), tree2 = configTree ? [
-      ...configTree.map(
-        (node) => normalizeTreeNode(
-          node,
-          group.key,
-          pagesByFileID,
-          routesByFileID,
-          {
-            childTreeForGroup: (childGroup) => groupTree(childGroup, new Set(stack)),
-            config
-          }
-        )
-      ).filter((node) => node !== null),
-      ...defaultTree(
-        group.key,
-        groupPages.filter((page) => !configuredPageIDs?.has(page.fileID)),
-        routesByFileID
+    let groupPages = pagesByGroup.get(groupKey) ?? [], routesByFileID = routesByGroup.get(groupKey) ?? /* @__PURE__ */ new Map(), groupContentPath = group?.__meta.relativeContentPath ?? "content", placedPages = /* @__PURE__ */ new Set(), placedGroups = /* @__PURE__ */ new Set();
+    function normalizeEntry(entry, source) {
+      let id = nodeId(groupKey, source, entry.type);
+      if (entry.type === "page") {
+        if (entry.group) {
+          let target = entry.group, targetGroup = config.groups[target];
+          if (!targetGroup)
+            throw navigationError(
+              `Navigation references missing group "${target}".`,
+              groupKey,
+              target
+            );
+          if (targetGroup.parentKey !== groupKey)
+            throw navigationError(
+              `Group "${target}" must be a child of "${groupKey}".`,
+              groupKey,
+              target
+            );
+          if (placedGroups.has(target))
+            throw navigationError(
+              `Group "${target}" appears more than once in navigation.`,
+              groupKey,
+              target
+            );
+          return placedGroups.add(target), groupNode(
+            target,
+            "page",
+            entry.label,
+            entry.navigation ?? inheritedFallback,
+            stack,
+            source
+          );
+        }
+        let sourcePath = entry.file ?? "", page = sourcePathToPage.get(sourcePath), expectedPrefix = `${groupContentPath.replace(/\\/g, "/")}/`;
+        if (!sourcePath.startsWith(expectedPrefix))
+          throw navigationError(
+            `Page reference "${entry.file ?? ""}" does not belong to "${groupKey}".`,
+            groupKey,
+            entry.file ?? ""
+          );
+        if (!page || page.group !== groupKey) return null;
+        if (placedPages.has(page.fileID))
+          throw navigationError(
+            `Page "${entry.file}" appears more than once in navigation.`,
+            groupKey,
+            entry.file ?? ""
+          );
+        placedPages.add(page.fileID);
+        let route = routesByFileID.get(page.fileID);
+        if (!route)
+          throw navigationError(
+            `Page route is missing for "${entry.file}".`,
+            groupKey,
+            entry.file ?? ""
+          );
+        let children = entry.items?.map((child, index) => normalizeEntry(child, `${source}.${index}`)).filter((child) => child !== null);
+        return {
+          id,
+          type: "page",
+          label: entry.label ?? page.frontmatter.title,
+          href: route.path,
+          page: {
+            fileID: page.fileID,
+            group: page.group,
+            path: page.path,
+            frontmatter: page.frontmatter
+          },
+          ...children?.length ? { children } : {}
+        };
+      }
+      if (entry.type === "folder" && entry.group) {
+        let target = entry.group, targetGroup = config.groups[target];
+        if (!targetGroup)
+          throw navigationError(
+            `Navigation references missing group "${target}".`,
+            groupKey,
+            target
+          );
+        if (targetGroup.parentKey !== groupKey)
+          throw navigationError(
+            `Group "${target}" must be a child of "${groupKey}".`,
+            groupKey,
+            target
+          );
+        if (placedGroups.has(target))
+          throw navigationError(
+            `Group "${target}" appears more than once in navigation.`,
+            groupKey,
+            target
+          );
+        return placedGroups.add(target), groupNode(
+          target,
+          "folder",
+          entry.label,
+          entry.navigation ?? inheritedFallback,
+          stack,
+          source
+        );
+      }
+      if (entry.type === "section" || entry.type === "folder") {
+        let children = entry.items?.map((child, index) => normalizeEntry(child, `${source}.${index}`)).filter((child) => child !== null) ?? [];
+        return { id, type: entry.type, label: entry.label, children };
+      }
+      return entry.type === "link" ? { id, type: "link", label: entry.label, href: entry.url } : entry.type === "view" ? {
+        id,
+        type: "view",
+        ...entry.id ? { viewId: entry.id } : {},
+        ...entry.label ? { label: entry.label } : {},
+        items: entry.items.map((child, index) => normalizeEntry(child, `${source}.${index}`)).filter((child) => child !== null)
+      } : {
+        id,
+        type: "switch-view",
+        label: entry.label,
+        target: entry.target
+      };
+    }
+    let items = navigation?.items.map(
+      (entry, index) => normalizeEntry(entry, `navigation.items.${index}`)
+    ).filter((entry) => entry !== null) ?? [], automatic = defaultItems({
+      group: groupKey,
+      pages: groupPages.filter((page) => !placedPages.has(page.fileID)),
+      routes: routesByFileID,
+      childGroups: (childrenByGroup.get(groupKey) ?? []).filter(
+        (key) => !placedGroups.has(key)
+      ),
+      contentPath: groupContentPath,
+      sort: navigation?.sort,
+      sortWarning: navigation?.sortWarning,
+      onWarning: onNavigationWarning,
+      makeGroup: (key, presentation, label) => groupNode(
+        key,
+        presentation,
+        label,
+        inheritedFallback,
+        stack,
+        `default:${key}`
+      )
+    });
+    return items.push(...automatic), items;
+  }
+  let rootKeys = groupEntries.filter((group) => !group.parentKey).map((group) => group.key).sort((a, b) => a.localeCompare(b)), navigationByRoot = /* @__PURE__ */ new Map();
+  for (let rootGroup of rootKeys)
+    navigationByRoot.set(rootGroup, {
+      rootGroup,
+      items: buildGroupItems(
+        rootGroup,
+        config.groups[rootGroup]?.localNavigation ?? config.groups[rootGroup]?.navigation
       )
-    ] : defaultTree(group.key, groupPages, routesByFileID);
-    return stack.delete(groupKey), treeCache.set(groupKey, tree2), tree2;
+    });
+  for (let [rootGroup, navigation] of navigationByRoot) {
+    let inspect2 = function(nodes, path) {
+      for (let [index, node] of nodes.entries()) {
+        let source = `${path}.${index}`;
+        if (node.type === "view" && node.viewId) {
+          if (views.has(node.viewId))
+            throw navigationError(
+              `View ID "${node.viewId}" is duplicated.`,
+              rootGroup,
+              node.viewId,
+              source
+            );
+          views.set(node.viewId, source);
+        }
+        node.type === "switch-view" && switches.push({ target: node.target, source }), "children" in node && node.children && inspect2(node.children, source), node.type === "view" && inspect2(node.items, source);
+      }
+    };
+    var inspect = inspect2;
+    let views = /* @__PURE__ */ new Map(), switches = [];
+    inspect2(navigation.items, "navigation.items");
+    for (let control of switches) {
+      let viewTarget = typeof control.target == "string" ? void 0 : control.target.view, groupTarget = typeof control.target == "string" ? control.target : void 0;
+      if (viewTarget && !views.has(viewTarget))
+        throw navigationError(
+          `Switch-view target "${viewTarget}" does not exist.`,
+          rootGroup,
+          viewTarget,
+          control.source
+        );
+      if (groupTarget && !config.groups[groupTarget] && !views.has(groupTarget))
+        throw navigationError(
+          `Switch-view target "${groupTarget}" is neither a group nor a named view.`,
+          rootGroup,
+          groupTarget,
+          control.source
+        );
+    }
   }
   let groups = Object.fromEntries(
-    Object.values(config.groups).map((group) => {
-      let groupPages = pagesByGroup.get(group.key) ?? [], groupData = {
-        key: group.key,
-        title: group.title ?? group.key,
-        path: group.path,
-        origin: group.origin ?? (group.key === ROOT_CONTENT_GROUP_KEY ? void 0 : config.origin),
-        ancestry: group.ancestry,
-        ...group.og ? { og: group.og } : {},
-        meta: group.meta,
-        tree: groupTree(group.key),
-        pages: groupPages
+    groupEntries.map((group) => {
+      let rootGroup = group.ancestry[0] ?? group.key, navigation = navigationByRoot.get(rootGroup) ?? {
+        rootGroup,
+        items: []
       };
-      return [group.key, groupData];
+      return [
+        group.key,
+        {
+          key: group.key,
+          title: group.title ?? group.key,
+          path: group.path,
+          origin: group.origin ?? (group.key === ROOT_CONTENT_GROUP_KEY ? void 0 : config.origin),
+          ancestry: group.ancestry,
+          ...group.metadata ? { metadata: group.metadata } : {},
+          meta: group.meta,
+          navigation,
+          pages: pagesByGroup.get(group.key) ?? []
+        }
+      ];
     })
-  ), tree = Object.values(groups).filter((group) => !config.groups[group.key]?.parentKey).flatMap(
-    (group) => group.key === ROOT_CONTENT_GROUP_KEY ? group.tree : [
-      {
-        type: "section",
-        id: group.key,
-        title: group.title,
-        path: group.path,
-        group: group.key,
-        children: group.tree
-      }
-    ]
   ), manifest = {
     site: content.site,
     groups,
-    tree,
     routes: content.routes,
     pages,
     contentHash: ""
@@ -1466,7 +1732,8 @@ function createManifest(config, content) {
 // src/lib/compiler/source/prepare-publish-os-source.ts
 async function preparePublishOsSource({
   publishOsDir,
-  sourceIdentity
+  sourceIdentity,
+  includeDrafts = !1
 }) {
   try {
     let sourceRoot = resolve5(publishOsDir), boundary = await assertPublishOsSourceBoundary(
@@ -1475,35 +1742,41 @@ async function preparePublishOsSource({
     ), config = await resolvePublishOsConfig(sourceRoot), content = await scanContent(config), media = await buildMediaAssets({
       config,
       publishOsDir
-    }), faviconsAndLogos = await buildFaviconsAndLogos({ publishOsDir }), missingPages = await missingPageReferences({
+    }), faviconsAndLogos = buildFaviconsAndLogos({
+      media
+    }), missingPages = await missingPageReferences({
       sourceRoot,
       config,
       content
-    });
+    }), sourceDiagnostics = [
+      ...boundary.nestedSources.map((file) => ({
+        code: "SOURCE_NESTED_EXCLUDED",
+        level: "warning",
+        message: "Nested publish.os source is excluded from this site.",
+        details: { file }
+      })),
+      ...content.warnings,
+      ...missingPages,
+      ...faviconsAndLogos.warnings,
+      ...media.warnings.map((warning2) => ({
+        ...warning2,
+        level: "warning"
+      }))
+    ];
+    if (missingPages.some((diagnostic) => diagnostic.level === "error"))
+      return { diagnostics: sourceDiagnostics };
+    let navigationWarnings = [], manifest = createManifest(
+      config,
+      includeDrafts ? { ...content, routes: content.candidateRoutes } : content,
+      (warning2) => navigationWarnings.push(warning2)
+    );
     return {
-      diagnostics: [
-        ...boundary.nestedSources.map((file) => ({
-          code: "SOURCE_NESTED_EXCLUDED",
-          level: "warning",
-          message: "Nested publish.os source is excluded from this site.",
-          details: { file }
-        })),
-        ...content.warnings,
-        ...missingPages,
-        ...media.warnings.map((warning2) => ({
-          ...warning2,
-          level: "warning"
-        })),
-        ...faviconsAndLogos.warnings.map((warning2) => ({
-          ...warning2,
-          level: "warning"
-        }))
-      ],
+      diagnostics: [...sourceDiagnostics, ...navigationWarnings],
       source: {
         assets: { faviconsAndLogos, media },
         config,
         content,
-        manifest: createManifest(config, content)
+        manifest
       }
     };
   } catch (error) {
@@ -1521,12 +1794,12 @@ async function preparePublishOsSource({
 
 // src/lib/compiler/theme/theme-token-diagnostics.ts
 import { readdirSync, readFileSync } from "fs";
-import { extname as extname2, join as join3, resolve as resolve6 } from "path";
+import { extname as extname3, join as join3, resolve as resolve6 } from "path";
 import postcss from "postcss";
 function cssFiles(directory) {
   return readdirSync(directory, { withFileTypes: !0 }).flatMap((entry) => {
     let path = join3(directory, entry.name);
-    return entry.isDirectory() ? cssFiles(path) : extname2(entry.name) === ".css" ? [path] : [];
+    return entry.isDirectory() ? cssFiles(path) : extname3(entry.name) === ".css" ? [path] : [];
   });
 }
 function readDesignTokens() {
@@ -1587,17 +1860,19 @@ var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   "GroupContext",
   "LayoutProps",
   "ManifestLike",
-  "NavFolder",
-  "NavItem",
-  "NavLink",
-  "NavPage",
-  "NavSection",
+  "NavigationContainerNode",
+  "NavigationGroupNode",
+  "NavigationLinkNode",
+  "NavigationNode",
+  "NavigationPageNode",
+  "NavigationSwitchViewNode",
+  "NavigationViewNode",
   "PageData",
   "PageProps",
+  "ResolvedNavigation",
   "RootLayoutProps",
   "RootPageProps",
-  "SiteData",
-  "TreeNode"
+  "SiteData"
 ]), ROUTE_EXECUTION_EXPORTS = [
   "runtime",
   "dynamic",
@@ -1647,7 +1922,7 @@ function normalizeLocalFontSourcePath(value) {
   return value.replace(/^\/+/, "").replace(/^\.\//, "");
 }
 function isFontFilePath(path) {
-  return FONT_FILE_EXTENSIONS.has(extname3(path).toLowerCase());
+  return FONT_FILE_EXTENSIONS.has(extname4(path).toLowerCase());
 }
 function isValidSourceFontFilePath(path) {
   return path.startsWith("fonts/") && isFontFilePath(path);
@@ -1692,7 +1967,7 @@ async function validateConfiguredLocalFontSources({
   return sourcePaths;
 }
 function isHardRejectedPath(path) {
-  let name = basename(path);
+  let name = basename2(path);
   return isReservedFrameworkPath(path) || path.split("/").some((segment) => ["packages", "scripts"].includes(segment)) || LOCKFILES.has(name) || name === "tsconfig.json" && path !== "tsconfig.json";
 }
 function isAllowedBareImport(specifier) {
@@ -1704,6 +1979,10 @@ function isAllowedBareImport(specifier) {
   }
   return ALLOWED_BARE_IMPORTS.has(specifier);
 }
+function isOriginalDefaultComponentBridge(options) {
+  let sourcePath = originalDefaultComponentSourcePath(options.specifier);
+  return sourcePath ? options.relativeFile.replace(/\.[^.]+$/, "") === sourcePath : !1;
+}
 function addFileError(store, code, message, file, details = {}) {
   store.error(code, message, { ...details, file });
 }
@@ -1790,7 +2069,7 @@ function importDetails(options) {
   };
 }
 function scriptKindForPath(path) {
-  switch (extname3(path).toLowerCase()) {
+  switch (extname4(path).toLowerCase()) {
     case ".tsx":
       return ts2.ScriptKind.TSX;
     case ".jsx":
@@ -2029,7 +2308,7 @@ function validateSourceFilePath({
   groupFolders,
   store
 }) {
-  if (basename(file) === "leaf.tsx" && (file === "leaf.tsx" || groupFolders.has(dirname(file))) || file.split("/").includes("(leaf)")) {
+  if (basename2(file) === "leaf.tsx" && (file === "leaf.tsx" || groupFolders.has(dirname(file))) || file.split("/").includes("(leaf)")) {
     let suggestedPath = file.replaceAll("(leaf)", "(page)").replace(/leaf\.tsx$/, "page.tsx");
     return addFileError(
       store,
@@ -2056,7 +2335,7 @@ function validateSourceFontFile({
   return isValidSourceFontFilePath(file) ? (configured || addFileWarning(
     store,
     "FRAMEWORK_FONT_FILE_UNUSED",
-    `Font file "${basename(file)}" is not used by the current font configuration and will not be included in the site.`,
+    `Font file "${basename2(file)}" is not used by the current font configuration and will not be included in the site.`,
     file,
     { fontSourcePath: `/${file}`, suggestion: fontConfigHint(file) }
   ), !0) : (addFileWarning(
@@ -2066,7 +2345,7 @@ function validateSourceFontFile({
     file,
     {
       fontSourcePath: `/${file}`,
-      suggestion: fontConfigHint(`fonts/${basename(file)}`)
+      suggestion: fontConfigHint(`fonts/${basename2(file)}`)
     }
   ), !0);
 }
@@ -2075,7 +2354,7 @@ function validateLegacyIconReferences(source, file, store) {
   match && addFileError(
     store,
     "FRAMEWORK_ICON_RESOLVER_REJECTED",
-    'The Icon resolver is removed. Import an exact component from "@phosphor-icons/react/ssr" in a custom MDX component instead.',
+    'The Icon resolver is removed. Import an exact named component from "@phosphor-icons/react/ssr" in MDX or TSX instead.',
     file,
     sourceDetails(source, match.index, match[0] ?? "")
   );
@@ -2107,7 +2386,7 @@ async function validateSourceFileContents({
   checkedCss,
   store
 }) {
-  let extension = extname3(file), sourceModule = SOURCE_EXTENSIONS.has(extension), validatesAttribution = ATTRIBUTION_VALIDATION_EXTENSIONS.has(extension), scansLegacyIcons = sourceModule || MARKDOWN_ICON_SCAN_EXTENSIONS.has(extension) && !file.startsWith("assets/");
+  let extension = extname4(file), sourceModule = SOURCE_EXTENSIONS.has(extension), validatesAttribution = ATTRIBUTION_VALIDATION_EXTENSIONS.has(extension), scansLegacyIcons = sourceModule || MARKDOWN_ICON_SCAN_EXTENSIONS.has(extension) && !file.startsWith("assets/");
   if (!validatesAttribution && !scansLegacyIcons) return;
   let absolutePath = resolve7(publishOsDir, file), source = await readFile5(absolutePath, "utf-8");
   validatesAttribution && validateAttributionReferences(source, file, store), extension === ".css" && (validateThemeTokenSpelling(source, file, store), await validateCssDependencies({
@@ -2115,7 +2394,23 @@ async function validateSourceFileContents({
     filePath: absolutePath,
     css: source,
     checked: checkedCss
-  })), scansLegacyIcons && validateLegacyIconReferences(source, file, store), sourceModule && (validateSourceModuleSafety(source, file, store), await validateSourceModule({
+  }));
+  let importsIconBinding = !1;
+  if (extension === ".mdx" && !file.startsWith("assets/"))
+    try {
+      importsIconBinding = (await validateMdxIconImports(source)).some(({ local }) => local === "Icon");
+    } catch (error) {
+      let line = error instanceof MdxIconImportError ? error.line : 1, column = error instanceof MdxIconImportError ? error.column : 1;
+      addFileError(
+        store,
+        error instanceof MdxIconImportError ? error.code : "FRAMEWORK_MDX_IMPORT_INVALID",
+        error instanceof Error ? error.message : String(error),
+        file,
+        { line, column, sourceLine: source.split(`
+`)[line - 1] ?? "" }
+      );
+    }
+  scansLegacyIcons && !importsIconBinding && validateLegacyIconReferences(source, file, store), sourceModule && (validateSourceModuleSafety(source, file, store), await validateSourceModule({
     absolutePath,
     groupFolders,
     publishOsDir,
@@ -2140,18 +2435,32 @@ async function validateSourceBoundary(publishOsDir, config, store) {
     "package.json"
   );
   for (let file of await walkAllFiles(publishOsDir))
-    validateSourceFilePath({ file, groupFolders, store }) && (validateSourceFontFile({ file, configuredFontSourcePaths, store }) || (isApprovedPublishOsPath(file, groupFolders) || addFileWarning(
-      store,
-      "FRAMEWORK_SOURCE_PATH_IGNORED",
-      "This file is outside the supported publish.os structure and will not be included in the site.",
-      file
-    ), await validateSourceFileContents({
-      publishOsDir,
-      file,
-      groupFolders,
-      checkedCss,
-      store
-    })));
+    if (validateSourceFilePath({ file, groupFolders, store }) && !validateSourceFontFile({ file, configuredFontSourcePaths, store })) {
+      if (!isApprovedPublishOsPath(file, groupFolders))
+        if (file.startsWith("public/")) {
+          let assetPath = file.slice(7);
+          addFileWarning(
+            store,
+            "FRAMEWORK_SOURCE_PUBLIC_UNSUPPORTED",
+            `Files in publish.os/public are not included. Move this file to publish.os/assets/${assetPath} and reference it as /assets/${assetPath}.`,
+            file,
+            { correction: `assets/${assetPath}` }
+          );
+        } else
+          addFileWarning(
+            store,
+            "FRAMEWORK_SOURCE_PATH_IGNORED",
+            "This file is outside the supported publish.os structure and will not be included in the site.",
+            file
+          );
+      await validateSourceFileContents({
+        publishOsDir,
+        file,
+        groupFolders,
+        checkedCss,
+        store
+      });
+    }
 }
 async function validateCssDependencies({
   publishOsDir,
@@ -2296,7 +2605,7 @@ async function validateImportSpecifier(options) {
     );
     return;
   }
-  isAllowedBareImport(options.specifier) || addFileError(
+  !isAllowedBareImport(options.specifier) && !isOriginalDefaultComponentBridge(options) && addFileError(
     options.store,
     "FRAMEWORK_IMPORT_NOT_ALLOWED",
     `Can't import from "${options.specifier}". Source modules can only import approved runtime packages.`,
@@ -2304,10 +2613,18 @@ async function validateImportSpecifier(options) {
     importDetails(options)
   );
 }
-function toValidationDiagnostic(diagnostic) {
+function toValidationDiagnostic(diagnostic, sourceRoot) {
+  let path = diagnostic.details?.file ?? diagnostic.details?.path ?? diagnostic.file, file = typeof path == "string" && isSameOrDescendant(sourceRoot, resolve7(sourceRoot, path)) ? relative4(sourceRoot, resolve7(sourceRoot, path)).split(sep).join("/") : void 0;
   return {
     ...diagnostic,
-    file: typeof diagnostic.details?.file == "string" ? diagnostic.details.file : diagnostic.file,
+    message: sourceRoot === parse(sourceRoot).root ? diagnostic.message : diagnostic.message.replaceAll(`${sourceRoot}${sep}`, ""),
+    file,
+    ...typeof diagnostic.details?.field == "string" && !diagnostic.details.propertyPath ? {
+      details: {
+        ...diagnostic.details,
+        propertyPath: diagnostic.details.field
+      }
+    } : {},
     line: typeof diagnostic.details?.line == "number" ? diagnostic.details.line : diagnostic.line,
     column: typeof diagnostic.details?.column == "number" ? diagnostic.details.column : diagnostic.column
   };
@@ -2322,7 +2639,8 @@ async function validatePublishOsSource(options) {
   try {
     let prepared = options.sourcePreparation ?? await preparePublishOsSource({
       publishOsDir,
-      sourceIdentity: options.sourceIdentity
+      sourceIdentity: options.sourceIdentity,
+      includeDrafts: options.includeDrafts
     });
     for (let diagnostic of prepared.diagnostics)
       store.add(diagnostic);
@@ -2330,7 +2648,7 @@ async function validatePublishOsSource(options) {
   } catch (error) {
     error instanceof AppError ? store.error(error.code, error.message, error.details) : store.error("FRAMEWORK_VALIDATE_UNKNOWN", String(error));
   }
-  let allDiagnostics = store.all().map(toValidationDiagnostic), errors = allDiagnostics.filter((d) => d.level === "error"), warnings = allDiagnostics.filter((d) => d.level === "warning"), valid = errors.length === 0;
+  let allDiagnostics = store.all().map((diagnostic) => toValidationDiagnostic(diagnostic, publishOsDir)), errors = allDiagnostics.filter((d) => d.level === "error"), warnings = allDiagnostics.filter((d) => d.level === "warning"), valid = errors.length === 0;
   return {
     valid,
     errors,