blume 2.1.2 → 2.2.0

package/dist/cli/{chunk-0pmb4tr4.js → chunk-8f8xw4x2.js}

@@ -4,6 +4,7 @@ import {
   localizeRoute,
   localizeInternalPath,
   i18nDiagnostics,
+  routeSetFor,
   blumeReferences,
   frontmatter_default,
   resolveLocalizable,
@@ -13,11 +14,16 @@ import {
   discoverPages,
   customStaticRoutes,
   nextFenceState,
+  resolveRelativeImage,
   hashText,
   pollingWatch,
   snapshotCache,
   loadWithCache,
+  MARKDOWN_BODY_FEATURES,
   MDX_BODY_FEATURES,
+  isExpression,
+  pageKey,
+  folderChildKeys,
   normalizeRef,
   isPageRef,
   pagesByRef,
@@ -28,7 +34,7 @@ import {
   hasVariables,
   substituteVariables,
   undefinedVariables,
-  pageMetaSchema,
+  BUILT_IN_PAGE_META_KEYS,
   folderMetaSchema,
   versionizeRoute,
   versionsDiagnostics,
@@ -36,6 +42,10 @@ import {
   slugifyPath,
   unloadablePathDiagnostic,
   frontmatterYamlDiagnostic,
+  ATTRIBUTE,
+  trailingCurlyMarker,
+  HTML_COMMENT,
+  INLINE_CODE,
   extractHeadings,
   strippedLineOffset,
   isStringValue,
@@ -45,7 +55,8 @@ import {
   normalizeEntry,
   hasIncludeStatements,
   expandIncludes,
-  parseYouTubeId,
+  youtubeEmbedSrc,
+  buildManifest,
   nodeRequire,
   escapeMarkdownText,
   guardBlockStart,
@@ -74,21 +85,24 @@ import {
   asObject,
   asNumber,
   objectsIn,
+  mirroredPage,
   createModuleLoader,
   resolveProjectContext,
   loadConfig
-} from "./chunk-124fvmzq.js";
+} from "./chunk-dm4mg9bj.js";
 import {
-  getBlumeVersion,
   BlumeError,
-  diagnosticsFromZod
+  locatePath,
+  diagnosticsFromZod,
+  closestMatch
 } from "./index.js";
 import {
   trimChar,
   normalizePath,
   isInternalPath,
   withBasePath,
-  mountBasePath
+  mountBasePath,
+  stripBasePath
 } from "./chunk-zccbjcj0.js";
 import {
   BLUME_IGNORE_DIRS,
@@ -195,9 +209,12 @@ var validateSearchPopularIcons = (popular) => {
   return unknownIconDiagnostics(icons, ICON_FORMAT_HINT);
 };
 var resolvesToPages = (routes, path) => routes.has(path) || [...routes].some((route) => route.startsWith(`${path}/`));
-var validateNavTargets = (navigation, routes) => {
+var validateNavTargets = (navigation, routes, servesFile = () => false) => {
   const targets = [
-    ...navigation.tabs.map((tab) => ({ label: tab.label, path: tab.path })),
+    ...navigation.tabs.map((tab) => ({
+      label: tab.label,
+      path: tab.href ?? tab.path
+    })),
     ...navigation.selectors.flatMap((selector) => selector.items.map((item) => ({ label: item.label, path: item.path }))),
     ...navigation.featured.map((link) => ({
       label: link.label,
@@ -215,7 +232,8 @@ var validateNavTargets = (navigation, routes) => {
     if (!isInternalPath(path) || path.startsWith("/#") || seen.has(path)) {
       continue;
     }
-    if (!resolvesToPages(routes, path.split(/[?#]/u)[0] ?? path)) {
+    const bare = path.split(/[?#]/u)[0] ?? path;
+    if (!(resolvesToPages(routes, bare) || servesFile(bare))) {
       seen.add(path);
       diagnostics.push({
         code: "BLUME_NAV_MISSING_PAGE",
@@ -324,133 +342,12 @@ var validateNavStructure = (navigation, pages) => [
   ...hiddenInSidebarDiagnostics(navigation, pages)
 ];
 
-// src/core/manifest.ts
-var versionAlternateKey = (versionKey, locale) => `${versionKey}\x00${locale}`;
-var versionAlternatesFor = (byKey, versionKey, locale) => {
-  const key = versionAlternateKey(versionKey, locale);
-  const existing = byKey.get(key);
-  if (existing) {
-    return existing;
-  }
-  const list = [];
-  byKey.set(key, list);
-  return list;
-};
-var MANIFEST_VERSION = 1;
-var contentIndexable = (page, config) => !page.meta.search.exclude && (!page.meta.sidebar.hidden || config.search.indexing.includeHiddenPages);
-var routeDescription = (page) => page.meta.seo.description ?? page.description;
-var buildFallbackRoutes = (graph, i18n, alternatesByKey, basePath, versionAlternatesByKey) => {
-  const fallback = resolveFallbackLocale(i18n);
-  if (!fallback) {
-    return [];
-  }
-  const fallbackPages = new Map(graph.pages.flatMap((page) => page.locale === fallback && !page.monolingual ? [[page.translationKey, page]] : []));
-  const routes = [];
-  for (const { code } of i18n.locales) {
-    if (code === fallback) {
-      continue;
-    }
-    const present = new Set(graph.pages.flatMap((page) => page.locale === code ? [page.translationKey] : []));
-    for (const [key, source] of fallbackPages) {
-      if (present.has(key)) {
-        continue;
-      }
-      const path = mountBasePath(basePath, localizeRoute(key, code, i18n));
-      const versionAlternates = versionAlternatesByKey ? versionAlternatesFor(versionAlternatesByKey, source.versionKey, code) : [];
-      if (versionAlternatesByKey) {
-        versionAlternates.push({ path, version: source.version });
-      }
-      routes.push({
-        alternates: alternatesByKey.get(key) ?? [],
-        collection: source.collection ?? "docs",
-        contentType: source.contentType,
-        description: routeDescription(source),
-        draft: source.meta.draft,
-        editUrl: source.editUrl,
-        entryId: source.entryId ?? source.source.ref,
-        fallback: true,
-        hidden: source.meta.sidebar.hidden,
-        id: source.id,
-        indexable: false,
-        lastModified: source.lastModified,
-        locale: code,
-        monolingual: source.monolingual,
-        path,
-        source: source.source,
-        sourcePath: source.sourcePath,
-        title: source.title,
-        version: source.version,
-        versionAlternates
-      });
-    }
-  }
-  return routes;
-};
-var buildManifest = (options) => {
-  const { context, config, graph } = options;
-  const searchEnabled = config.search.provider.mode !== "none";
-  const { i18n } = config;
-  const alternatesByKey = new Map;
-  if (i18n) {
-    for (const page of graph.pages) {
-      const list = alternatesByKey.get(page.translationKey) ?? [];
-      list.push({ locale: page.locale, path: page.route });
-      alternatesByKey.set(page.translationKey, list);
-    }
-  }
-  const versionAlternatesByKey = config.versions ? new Map : undefined;
-  if (versionAlternatesByKey) {
-    for (const page of graph.pages) {
-      versionAlternatesFor(versionAlternatesByKey, page.versionKey, page.locale).push({ path: page.route, version: page.version });
-    }
-  }
-  const routes = graph.pages.map((page) => ({
-    aiExclude: page.meta.ai.exclude,
-    alternates: alternatesByKey.get(page.translationKey) ?? [],
-    collection: page.collection ?? "docs",
-    contentType: page.contentType,
-    description: routeDescription(page),
-    draft: page.meta.draft,
-    editUrl: page.editUrl,
-    entryId: page.entryId ?? page.source.ref,
-    hidden: page.meta.sidebar.hidden,
-    id: page.id,
-    indexable: searchEnabled && contentIndexable(page, config),
-    lastModified: page.lastModified,
-    locale: page.locale,
-    monolingual: page.monolingual,
-    path: page.route,
-    source: page.source,
-    sourcePath: page.sourcePath,
-    title: page.title,
-    version: page.version,
-    versionAlternates: versionAlternatesByKey ? versionAlternatesFor(versionAlternatesByKey, page.versionKey, page.locale) : []
-  }));
-  if (i18n) {
-    routes.push(...buildFallbackRoutes(graph, i18n, alternatesByKey, config.basePath, versionAlternatesByKey));
-  }
-  if (versionAlternatesByKey && config.versions) {
-    const rank = new Map(config.versions.archived.map((version, index) => [version.id, index + 1]));
-    for (const list of versionAlternatesByKey.values()) {
-      list.sort((a, b) => (rank.get(a.version) ?? 0) - (rank.get(b.version) ?? 0));
-    }
-  }
-  routes.sort((a, b) => a.path.localeCompare(b.path));
-  return {
-    blumeVersion: getBlumeVersion(),
-    contentRoot: context.contentRoot,
-    output: config.deployment.options.output,
-    projectRoot: context.root,
-    routes,
-    version: MANIFEST_VERSION
-  };
-};
-
 // src/core/project-graph.ts
-import { isAbsolute as isAbsolute3, relative as relative5 } from "pathe";
+import { existsSync as existsSync3 } from "node:fs";
+import { isAbsolute as isAbsolute3, join as join8, relative as relative5 } from "pathe";
 
-// src/core/directive-diagnostics.ts
-import { mdxToMdast } from "satteri";
+// src/core/alert-diagnostics.ts
+import { markdownToMdast } from "satteri";
 
 // src/markdown/directives.ts
 import { toString as mdastToString } from "mdast-util-to-string";
@@ -498,25 +395,366 @@ var directiveSource = (node, marker, source) => {
   return `${opening}${labelSource(node.children ?? [])}${attributeSource(node)}`;
 };
 
+// src/markdown/github-alerts.ts
+var ALERT_CALLOUTS = new Map([
+  ["caution", "danger"],
+  ["important", "note"],
+  ["note", "note"],
+  ["tip", "tip"],
+  ["warning", "warning"]
+]);
+var ALERT_MARKER = /^\[!(?<kind>[a-z]+)\]/iu;
+var alertMarkerOf = (text) => {
+  const match = ALERT_MARKER.exec(text);
+  const callout = ALERT_CALLOUTS.get(match?.groups?.kind?.toLowerCase() ?? "");
+  return match && callout ? { callout, marker: match[0] } : undefined;
+};
+
+// src/core/alert-diagnostics.ts
+var ALERT_LINE = /^[\t >]*>[\t ]*\[![a-z]+\]/imu;
+var alertFindings = (text) => {
+  if (!ALERT_LINE.test(text)) {
+    return [];
+  }
+  const tree = markdownToMdast(text, {
+    features: MARKDOWN_BODY_FEATURES
+  });
+  const found = [];
+  const walk = (node) => {
+    if (node.type === "blockquote") {
+      const [paragraph] = node.children;
+      const first = paragraph?.type === "paragraph" ? paragraph.children[0] : undefined;
+      const escaped = text[first?.position?.start.offset ?? 0] === "\\";
+      const alert = first?.type === "text" && !escaped ? alertMarkerOf(first.value) : undefined;
+      if (alert !== undefined) {
+        found.push({ ...alert, line: node.position?.start.line ?? 1 });
+        return;
+      }
+    }
+    if ("children" in node) {
+      for (const child of node.children) {
+        walk(child);
+      }
+    }
+  };
+  walk(tree);
+  return found;
+};
+var alertDiagnostics = (entry, sourceName) => {
+  if (entry.body.format !== "md") {
+    return [];
+  }
+  const page = entry.sourcePath ?? `${sourceName}:${entry.ref}`;
+  const offset = entry.bodyLineOffset ?? strippedLineOffset(entry.raw, entry.body.text);
+  return alertFindings(entry.expanded?.text ?? entry.body.text).map(({ callout, line, marker }) => {
+    const origin = entry.expanded?.origins[line - 1];
+    return {
+      code: "BLUME_MD_GITHUB_ALERT",
+      file: origin?.file ?? page,
+      line: origin?.line ?? line + offset,
+      message: `\`${marker}\` makes a quote a callout only in .mdx; in this .md page it renders as a quote that shows \`${marker}\` as text.`,
+      severity: "warning",
+      suggestion: `Rename the page to .mdx to render it as a \`${callout}\` callout, or remove \`${marker}\` to keep a plain quote.`
+    };
+  });
+};
+
+// src/core/code-fence-diagnostics.ts
+import { markdownToMdast as markdownToMdast2, mdxToMdast } from "satteri";
+
+// src/markdown/fence-language.ts
+import { bundledLanguages } from "shiki/langs";
+var PLAIN_LANGUAGES = new Set([
+  "ansi",
+  "plain",
+  "plaintext",
+  "text",
+  "txt"
+]);
+var isKnownLanguage = (lang) => PLAIN_LANGUAGES.has(lang) || Object.hasOwn(bundledLanguages, lang);
+var GLUED_RANGE = /^(?<lang>[^{]+)(?<range>\{[^}]*\})$/u;
+var GLUED_TITLE_RANGE = /(?<=^|\s)(?<title>\[[^\]]*\])(?<range>\{[^}]*\})(?=\s|$)/u;
+var normalizeFence = (lang, meta) => {
+  if (!lang) {
+    return null;
+  }
+  const glued = GLUED_RANGE.exec(lang)?.groups;
+  const id = glued?.lang ?? lang;
+  const fenceMeta = (glued?.range ? [glued.range, meta].filter(Boolean).join(" ") : meta)?.replace(GLUED_TITLE_RANGE, "$<title> $<range>") ?? null;
+  const lower = id.toLowerCase();
+  const language = !isKnownLanguage(id) && isKnownLanguage(lower) ? lower : id;
+  return language === lang && fenceMeta === (meta ?? null) ? null : { lang: language, meta: fenceMeta };
+};
+
+// src/markdown/fence-meta.ts
+var QUOTED_ATTR = /[\w-]+=(?:"[^"]*"|'[^']*')/gu;
+var LINE_RANGE = /\{[^}]*\}/u;
+var META_TOKEN = new RegExp(`${QUOTED_ATTR.source}|${LINE_RANGE.source}|\\S+`, "gu");
+var metaTokens = (meta) => meta?.match(META_TOKEN) ?? [];
+var RESERVED_META_KEYWORDS = new Set([
+  "expandable",
+  "lineNumbers",
+  "ts2js",
+  "twoslash",
+  "wrap"
+]);
+var FOREIGN_META_KEYWORDS = new Set([
+  "lines",
+  "wordWrap"
+]);
+var SHOW_LINE_NUMBERS = /^showLineNumbers(?:\{\d*\})?$/u;
+var RUST_META_KEYWORDS = new Set([
+  "compile_fail",
+  "edition2015",
+  "edition2018",
+  "edition2021",
+  "edition2024",
+  "editable",
+  "ignore",
+  "no_run",
+  "noplayground",
+  "should_panic"
+]);
+var RUST_LANGUAGES = new Set(["rs", "rust"]);
+var isForeignKeyword = (token, lang) => FOREIGN_META_KEYWORDS.has(token) || SHOW_LINE_NUMBERS.test(token) || RUST_LANGUAGES.has(lang ?? "") && RUST_META_KEYWORDS.has(token);
+var isLineRange = (token) => token.startsWith("{");
+
+// src/core/code-fence-diagnostics.ts
+var BLUME_LANGUAGES = new Set([
+  "math",
+  "package-install"
+]);
+var lineRange = (value) => `{${value.trim().split(/[\s,]+/u).join(",")}}`;
+var FOREIGN_OPTIONS = [
+  {
+    effect: "the block highlights no lines",
+    instead: (value) => `Put the lines in braces after the language instead: \`${lineRange(value)}\`.`,
+    pattern: /^hl_lines=["'](?<value>[^"']*)["']$/u
+  },
+  {
+    effect: "the block shows no line numbers",
+    instead: (value) => `Write \`lineNumbers\` after the language instead.${value.trim() === "1" ? "" : " Blume numbers every block from 1."}`,
+    pattern: /^linenums=["'](?<value>[^"']*)["']$/u
+  },
+  {
+    effect: "the block shows no line numbers",
+    instead: () => "Write `lineNumbers` after the language instead.",
+    pattern: /^showLineNumbers(?:\{\d*\})?$/u
+  },
+  {
+    effect: "the block shows no line numbers",
+    instead: () => 'Write `lineNumbers` after the language instead. To keep the word in the block\'s title, set the title with `title="…"`.',
+    pattern: /^lines$/u
+  },
+  {
+    effect: "the block doesn't wrap its long lines",
+    instead: () => "Write `wrap` after the language instead.",
+    pattern: /^wordWrap$/u
+  },
+  {
+    effect: "the block has no title",
+    instead: (value) => `Write \`title="${value}"\` instead.`,
+    pattern: /^filename=["'](?<value>[^"']*)["']$/u
+  },
+  {
+    effect: "it does nothing: Blume shows a code block as static text, and never compiles, tests, or runs it",
+    instead: () => "Remove it.",
+    languages: RUST_LANGUAGES,
+    pattern: new RegExp(`^(?:${[...RUST_META_KEYWORDS].join("|")})$`, "u")
+  }
+];
+var foreignOption = (token, lang) => {
+  for (const option of FOREIGN_OPTIONS) {
+    const match = option.pattern.exec(token);
+    if (match && (option.languages?.has(lang) ?? true)) {
+      return { option, value: match.groups?.value ?? "" };
+    }
+  }
+  return null;
+};
+var rendersLanguage = (lang) => isKnownLanguage(lang) || BLUME_LANGUAGES.has(lang);
+var fenceParts = (lang, meta) => {
+  const fence = normalizeFence(lang, meta) ?? {
+    lang: lang ?? "",
+    meta: meta ?? null
+  };
+  return { lang: fence.lang, meta: fence.meta, tokens: metaTokens(fence.meta) };
+};
+var unknownLanguage = (node, line) => {
+  const { lang } = fenceParts(node.lang, node.meta);
+  if (!lang || rendersLanguage(lang)) {
+    return [];
+  }
+  return [
+    {
+      code: "BLUME_UNKNOWN_CODE_LANGUAGE",
+      line,
+      message: `\`${lang}\` isn't a language Blume can highlight, so the code block renders as plain text.`,
+      suggestion: 'Use a Shiki language id or alias (https://shiki.style/languages), or `text` for plain text. Options like a title go after the language, as in `text title="notes.txt"`.'
+    }
+  ];
+};
+var foreignOptions = (node, line) => {
+  const { lang, tokens } = fenceParts(node.lang, node.meta);
+  return [node.lang ?? "", ...tokens].flatMap((token) => {
+    const found = foreignOption(token, lang);
+    if (!found) {
+      return [];
+    }
+    return [
+      {
+        code: "BLUME_CODE_FENCE_OPTION",
+        line,
+        message: `\`${token}\` isn't a Blume code block option, so ${found.option.effect}.`,
+        suggestion: found.option.instead(found.value)
+      }
+    ];
+  });
+};
+var FENCE_INFO = /(?:`{3,}|~{3,})[\t ]*(?<info>[^`\n]*)/gu;
+var suspectInfo = (info) => {
+  const [lang, ...rest] = info.trim().split(/\s+/u);
+  if (!lang) {
+    return false;
+  }
+  const parts = fenceParts(lang, rest.join(" ") || null);
+  return !rendersLanguage(parts.lang) || [lang, ...parts.tokens].some((token) => foreignOption(token, parts.lang) !== null);
+};
+var parse = (text, format) => {
+  try {
+    return format === "mdx" ? mdxToMdast(text, { features: MDX_BODY_FEATURES }) : markdownToMdast2(text, { features: MARKDOWN_BODY_FEATURES });
+  } catch {
+    return null;
+  }
+};
+var fenceFindings = (text, format) => {
+  const suspect = [...text.matchAll(FENCE_INFO)].some((match) => suspectInfo(match.groups?.info ?? ""));
+  const tree = suspect ? parse(text, format) : null;
+  if (!tree) {
+    return [];
+  }
+  const found = [];
+  const walk = (node) => {
+    if (node.type === "code") {
+      const line = node.position?.start.line ?? 1;
+      found.push(...unknownLanguage(node, line), ...foreignOptions(node, line));
+    }
+    if ("children" in node) {
+      for (const child of node.children) {
+        walk(child);
+      }
+    }
+  };
+  walk(tree);
+  return found;
+};
+var codeFenceDiagnostics = (entry, sourceName) => {
+  const page = entry.sourcePath ?? `${sourceName}:${entry.ref}`;
+  const offset = entry.bodyLineOffset ?? strippedLineOffset(entry.raw, entry.body.text);
+  return fenceFindings(entry.expanded?.text ?? entry.body.text, entry.body.format).map(({ line, ...finding }) => {
+    const origin = entry.expanded?.origins[line - 1];
+    return {
+      ...finding,
+      file: origin?.file ?? page,
+      line: origin?.line ?? line + offset,
+      severity: "warning"
+    };
+  });
+};
+
 // src/core/directive-diagnostics.ts
+import { markdownToMdast as markdownToMdast3, mdxToMdast as mdxToMdast2 } from "satteri";
 var CONTAINER_OPENING = /^[\t >]*:{3,}(?<name>[a-z][\w-]*)/gimu;
+var FENCE_WITH_TEXT = /^[\t >]*:{3,}(?:[\t ]+\S|[^\s:a-z])/imu;
+var CLOSING_LINE = /^[\t >]*(?<written>(?<fence>:{3,})[\t ]*(?<text>.*?))\s*$/u;
+var OPENING_TEXT = /^[\t >]*(?<written>(?<fence>:{3,})(?<name>[a-z][\w-]*)(?<label>\[[^\]\n]*\])?(?<attributes>\{[^}\n]*\})?[\t ]+(?<text>\S.*?))\s*$/iu;
+var OPENING_TEXT_LINE = /^[\t >]*:{3,}[a-z][\w-]*(?:\[[^\]\n]*\])?(?:\{[^}\n]*\})?[\t ]+\S/imu;
+var SPACED_OPENING = /^[\t >]*(?<written>(?<fence>:{3,})[\t ]+(?<name>[a-z][\w-]*)(?<title>.*?))\s*$/iu;
+var MD_OPENING = /^[\t >]*(?<written>:{3,}(?<name>[a-z][\w-]*))/iu;
+var MD_OPENING_LINE = /^[\t >]*:{3,}[a-z]/imu;
 var codeList = (names) => [...names].map((name) => `\`${name}\``).join(", ");
 var CALLOUT_NAMES = `${codeList(CALLOUT_TYPES)} (or the aliases ${codeList(Object.keys(CALLOUT_ALIASES))})`;
-var unknownContainers = (text) => {
-  const named = [...text.matchAll(CONTAINER_OPENING)].some((match) => calloutTypeFor(match.groups?.name ?? "") === null);
-  if (!named) {
+var unknownContainer = (node) => calloutTypeFor(node.name) === null ? [
+  {
+    code: "BLUME_UNKNOWN_DIRECTIVE",
+    line: node.position?.start.line ?? 1,
+    message: `\`:::${node.name}\` isn't a callout type, so the page shows its \`:::\` lines as written around its content.`,
+    suggestion: `Use a callout type — ${CALLOUT_NAMES} — or remove the \`:::\` lines to keep the content as plain prose.`
+  }
+] : [];
+var closingText = (node, lines) => {
+  const start = node.position?.start.line ?? 1;
+  const end = node.position?.end.line ?? start;
+  const content = node.children.at(-1)?.position?.end.line ?? start;
+  const groups = end > content ? CLOSING_LINE.exec(lines[end - 1] ?? "")?.groups : undefined;
+  if (!(groups?.text && groups.fence && groups.written)) {
+    return [];
+  }
+  const longer = ":".repeat(groups.fence.length + 1);
+  return [
+    {
+      code: "BLUME_DIRECTIVE_CLOSING_TEXT",
+      line: end,
+      message: `\`${groups.written}\` closes the \`:::${node.name}\` container above it, so \`${groups.text}\` never reaches the page.`,
+      suggestion: `Give the container a longer fence than this line's — \`${longer}${node.name}\`, closed by \`${longer}\` — to keep the line inside it as text, or remove \`${groups.text}\` from the line.`
+    }
+  ];
+};
+var openingText = (node, lines) => {
+  const line = node.position?.start.line ?? 1;
+  const groups = OPENING_TEXT.exec(lines[line - 1] ?? "")?.groups;
+  if (!(groups?.fence && groups.name && groups.text && groups.written) || calloutTypeFor(node.name) === null) {
+    return [];
+  }
+  const opener = `${groups.fence}${groups.name}`;
+  return [
+    {
+      code: "BLUME_DIRECTIVE_OPENING_TEXT",
+      line,
+      message: `\`${groups.written}\` opens a \`${groups.name}\` callout, but the text after its name, \`${groups.text}\`, never reaches the page.`,
+      suggestion: groups.label || groups.attributes ? `Move \`${groups.text}\` into the callout's title, or onto the next line as its text.` : `Put the title in brackets: \`${opener}[${groups.text}]\`.`
+    }
+  ];
+};
+var spacedOpenings = (node, lines) => {
+  const start = node.position?.start.line ?? 1;
+  const end = node.position?.end.line ?? start;
+  return lines.slice(start - 1, end).flatMap((text, index) => {
+    const groups = SPACED_OPENING.exec(text)?.groups;
+    if (!(groups?.fence && groups.name && groups.written) || calloutTypeFor(groups.name) === null) {
+      return [];
+    }
+    const opener = `${groups.fence}${groups.name}`;
+    const title = groups.title?.trim();
+    return [
+      {
+        code: "BLUME_DIRECTIVE_SPACED_NAME",
+        line: start + index,
+        message: `\`${groups.written}\` has a space between its colons and its name, so it isn't a callout and the page shows it as text.`,
+        suggestion: title ? `Remove the space and put the title in brackets: \`${opener}[${title}]\`.` : `Remove the space: \`${opener}\`.`
+      }
+    ];
+  });
+};
+var directiveFindings = (text) => {
+  const suspect = FENCE_WITH_TEXT.test(text) || OPENING_TEXT_LINE.test(text) || [...text.matchAll(CONTAINER_OPENING)].some((match) => calloutTypeFor(match.groups?.name ?? "") === null);
+  if (!suspect) {
     return [];
   }
   let tree;
   try {
-    tree = mdxToMdast(text, { features: MDX_BODY_FEATURES });
+    tree = mdxToMdast2(text, { features: MDX_BODY_FEATURES });
   } catch {
     return [];
   }
+  const lines = text.split(`
+`);
   const found = [];
   const walk = (node) => {
-    if (node.type === "containerDirective" && calloutTypeFor(node.name) === null) {
-      found.push({ line: node.position?.start.line ?? 1, name: node.name });
+    if (node.type === "containerDirective") {
+      found.push(...unknownContainer(node), ...openingText(node, lines), ...closingText(node, lines));
+    } else if (node.type === "paragraph") {
+      found.push(...spacedOpenings(node, lines));
     }
     if ("children" in node) {
       for (const child of node.children) {
@@ -525,27 +763,83 @@ var unknownContainers = (text) => {
     }
   };
   walk(tree);
-  return found;
+  return found.toSorted((a, b) => a.line - b.line);
+};
+var mdOpenings = (node, lines) => {
+  const start = node.position?.start.line ?? 1;
+  const end = node.position?.end.line ?? start;
+  return lines.slice(start - 1, end).flatMap((text, index) => {
+    const groups = MD_OPENING.exec(text)?.groups;
+    if (!(groups?.name && groups.written)) {
+      return [];
+    }
+    const callout = calloutTypeFor(groups.name);
+    return [
+      {
+        code: "BLUME_MD_DIRECTIVE",
+        line: start + index,
+        message: `\`${groups.written}\` opens a directive, which Blume renders only in .mdx, so this .md page shows it and its closing \`:::\` as text.`,
+        suggestion: callout ? `Rename the page to .mdx to render it as a \`${callout}\` callout.` : `Rename the page to .mdx and use a callout type — ${CALLOUT_NAMES} — or remove the \`:::\` lines to keep the content as plain prose.`
+      }
+    ];
+  });
 };
-var unknownDirectiveDiagnostics = (entry, sourceName) => {
-  if (entry.body.format !== "mdx") {
+var mdDirectiveFindings = (text) => {
+  if (!MD_OPENING_LINE.test(text)) {
     return [];
   }
+  const tree = markdownToMdast3(text, {
+    features: MARKDOWN_BODY_FEATURES
+  });
+  const lines = text.split(`
+`);
+  const found = [];
+  const walk = (node) => {
+    if (node.type === "paragraph") {
+      found.push(...mdOpenings(node, lines));
+    } else if ("children" in node) {
+      for (const child of node.children) {
+        walk(child);
+      }
+    }
+  };
+  walk(tree);
+  return found;
+};
+var directiveDiagnostics = (entry, sourceName) => {
   const page = entry.sourcePath ?? `${sourceName}:${entry.ref}`;
   const offset = entry.bodyLineOffset ?? strippedLineOffset(entry.raw, entry.body.text);
-  return unknownContainers(entry.expanded?.text ?? entry.body.text).map(({ line, name }) => {
+  const text = entry.expanded?.text ?? entry.body.text;
+  const findings = entry.body.format === "mdx" ? directiveFindings(text) : mdDirectiveFindings(text);
+  return findings.map(({ line, ...finding }) => {
     const origin = entry.expanded?.origins[line - 1];
     return {
-      code: "BLUME_UNKNOWN_DIRECTIVE",
+      ...finding,
       file: origin?.file ?? page,
       line: origin?.line ?? line + offset,
-      message: `\`:::${name}\` isn't a callout type, so the page shows its \`:::\` lines as written around its content.`,
-      severity: "warning",
-      suggestion: `Use a callout type — ${CALLOUT_NAMES} — or remove the \`:::\` lines to keep the content as plain prose.`
+      severity: "warning"
     };
   });
 };
 
+// src/core/former-routes.ts
+var formerRouteRedirects = (pages, served, config) => {
+  const targets = new Map;
+  for (const page of pages) {
+    if (page.formerRoute !== undefined) {
+      targets.set(page.formerRoute, targets.has(page.formerRoute) ? undefined : page.route);
+    }
+  }
+  const authored = new Set(config.redirects.map((redirect) => normalizePath(withBasePath(config.basePath, redirect.from))));
+  return [...targets].flatMap(([from, to]) => to === undefined || served.has(from) || authored.has(from) ? [] : [
+    {
+      from: stripBasePath(config.basePath, from),
+      status: 301,
+      to: stripBasePath(config.basePath, to)
+    }
+  ]);
+};
+
 // src/core/graph.ts
 var collectRoutes = (pages) => {
   const routes = new Map;
@@ -810,13 +1104,33 @@ var gitEnv = () => Object.fromEntries(Object.entries(process.env).filter(([key])
 var resolveLastModifiedConfig = (value) => value === false ? { enabled: false, source: "git" } : { enabled: true, source: value };
 var parseGitLog = (output) => {
   const times = new Map;
+  const currentNames = new Map;
+  const renamedAt = new Map;
   let current = null;
   for (const line of output.split(`
 `)) {
     if (line.startsWith("\x00")) {
       current = line.slice(1);
-    } else if (line && current && !times.has(line)) {
-      times.set(line, current);
+      continue;
+    }
+    const [status = "", from = "", to] = line.split("\t");
+    const path = to ?? from;
+    if (!(current && path)) {
+      continue;
+    }
+    const name = currentNames.get(path) ?? path;
+    if (status.startsWith("R")) {
+      currentNames.set(from, name);
+      if (!renamedAt.has(name)) {
+        renamedAt.set(name, current);
+      }
+    } else if (!times.has(name)) {
+      times.set(name, current);
+    }
+  }
+  for (const [name, date] of renamedAt) {
+    if (!times.has(name)) {
+      times.set(name, date);
     }
   }
   return times;
@@ -852,7 +1166,8 @@ var gitLastModifiedTimes = (root, contentRoots, sourcePaths, repositoryRoot) =>
       "core.quotePath=false",
       "log",
       "--format=%x00%cI",
-      "--name-only",
+      "--name-status",
+      "-M100%",
       "--",
       ...contentRoots.map(realPath)
     ], { encoding: "utf-8", env: gitEnv(), maxBuffer: 256 * 1024 * 1024 });
@@ -894,6 +1209,245 @@ var lastModifiedShallowWarning = (root, undatedCount) => {
   ];
 };
 
+// src/core/mdx-syntax.ts
+import { readFile } from "node:fs/promises";
+import { createMdxMdastHandle, dropHandle, mdxToMdast as mdxToMdast3 } from "satteri";
+var POSITIONED = /^(?<line>\d+):(?<column>\d+): (?<reason>[\s\S]*?)(?: \([\w-]+:[\w-]+\))?$/u;
+var INNER_POSITION = / \((?<line>\d+):(?<column>\d+)\)/gu;
+var mdxSyntaxError = (text) => {
+  try {
+    dropHandle(createMdxMdastHandle(text, MDX_BODY_FEATURES, false));
+    return null;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const groups = POSITIONED.exec(message)?.groups;
+    return {
+      column: Number(groups?.column ?? 1),
+      line: Number(groups?.line ?? 1),
+      reason: groups?.reason ?? message
+    };
+  }
+};
+var sitesIn = (file, lineOffset, origins) => (line, column) => {
+  const origin = origins?.[line - 1];
+  return origin ? { column, file: origin.file, line: origin.line } : { column, file, line: line + lineOffset };
+};
+var placedReason = (reason, at, siteOf) => reason.replaceAll(INNER_POSITION, (written, line, column) => {
+  const inner = siteOf(Number(line), Number(column));
+  return inner.file === at.file ? ` (${inner.line}:${column})` : "";
+});
+var EXPRESSION_REASON = /could not parse expression/iu;
+var COMMENT_REASON = /to create a comment in MDX/u;
+var LINK_REASON = /to create a link in MDX/u;
+var syntaxSuggestion = (reason) => {
+  if (EXPRESSION_REASON.test(reason)) {
+    return "In .mdx, `{` starts a JavaScript expression. To show a brace as text, escape it (`\\{`) or put the text in inline code.";
+  }
+  if (COMMENT_REASON.test(reason)) {
+    return "Write the comment as `{/* … */}`.";
+  }
+  if (LINK_REASON.test(reason)) {
+    return "Write the link as `[text](https://…)`.";
+  }
+  return "MDX reads HTML as JSX: close every element (`<br />`, `<img … />`) and match each closing tag. A page that needs no components can be a .md file instead.";
+};
+var mdxSyntaxDiagnostic = (error, siteOf, options) => {
+  const at = siteOf(error.line, error.column);
+  const reason = placedReason(error.reason, at, siteOf);
+  return {
+    code: "BLUME_MDX_SYNTAX",
+    column: at.column,
+    file: at.file,
+    line: at.line,
+    message: options.includedIn ? `MDX can't parse this file once ${options.includedIn} includes it: ${reason}.` : `MDX can't parse this page: ${reason}.`,
+    severity: options.severity,
+    suggestion: syntaxSuggestion(reason)
+  };
+};
+var mdxSyntaxCheck = (entry, sourceName, variables) => {
+  if (entry.body.format !== "mdx") {
+    return { diagnostics: [], unparsable: false };
+  }
+  const siteOf = (origins) => sitesIn(entry.sourcePath ?? `${sourceName}:${entry.ref}`, entry.bodyLineOffset ?? strippedLineOffset(entry.raw, entry.body.text), origins);
+  const { expanded } = entry;
+  const body = expanded ? substituteVariables(entry.body.text, variables) : entry.body.text;
+  const own = mdxSyntaxError(body);
+  if (own) {
+    return {
+      diagnostics: [mdxSyntaxDiagnostic(own, siteOf(), { severity: "error" })],
+      unparsable: true
+    };
+  }
+  const spliced = expanded ? mdxSyntaxError(expanded.text) : null;
+  if (!(expanded && spliced)) {
+    return { diagnostics: [], unparsable: false };
+  }
+  return {
+    diagnostics: [
+      mdxSyntaxDiagnostic(spliced, siteOf(expanded.origins), {
+        includedIn: entry.ref,
+        severity: "warning"
+      })
+    ],
+    unparsable: false
+  };
+};
+var compiledText = async (page) => {
+  const raw = await readFile(page.sourcePath, "utf-8");
+  const body = frontmatter_default(raw).content;
+  const offset = strippedLineOffset(raw, body);
+  const expansion = page.contentRoot && hasIncludeStatements(body) ? await expandIncludes(body, {
+    contentRoot: page.contentRoot,
+    lineOffset: offset,
+    sourcePath: page.sourcePath
+  }) : null;
+  const written = expansion?.text ?? body;
+  return {
+    siteOf: sitesIn(page.sourcePath, offset, expansion?.origins),
+    text: substituteVariables(written, page.variables),
+    written
+  };
+};
+var readsName = (expression, name) => new RegExp(String.raw`(?<![\w$.])${name.replaceAll("$", String.raw`\$`)}(?![\w$])`, "u").test(expression.replaceAll("...", "   "));
+var expressionsOf = (node) => {
+  if (node.type === "mdxFlowExpression" || node.type === "mdxTextExpression") {
+    return [node.value];
+  }
+  if (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") {
+    return node.attributes.flatMap((attribute) => {
+      if (attribute.type === "mdxJsxExpressionAttribute") {
+        return [attribute.value];
+      }
+      return isExpression(attribute.value) ? [attribute.value.value] : [];
+    });
+  }
+  return [];
+};
+var expressionReading = (text, name) => {
+  let tree;
+  try {
+    tree = mdxToMdast3(text, { features: MDX_BODY_FEATURES });
+  } catch {
+    return null;
+  }
+  const visit = (node) => {
+    const expression = expressionsOf(node).find((source) => readsName(source, name));
+    if (expression !== undefined) {
+      return { expression: `{${expression.trim()}}`, node };
+    }
+    if ("children" in node) {
+      for (const child of node.children) {
+        const found = visit(child);
+        if (found) {
+          return found;
+        }
+      }
+    }
+    return null;
+  };
+  return visit(tree);
+};
+var locateMdxFailure = async (page, failure) => {
+  let compiled;
+  try {
+    compiled = await compiledText(page);
+  } catch {
+    return null;
+  }
+  const { siteOf, text, written } = compiled;
+  if (failure.kind === "undefined-name") {
+    const found = expressionReading(text, failure.name);
+    const start = found?.node.position?.start;
+    if (!(found && start)) {
+      return null;
+    }
+    const at = written.split(`
+`)[start.line - 1]?.indexOf(found.expression) ?? -1;
+    return {
+      ...siteOf(start.line, at === -1 ? start.column : at + 1),
+      expression: found.expression
+    };
+  }
+  const error = mdxSyntaxError(text);
+  if (!error) {
+    return null;
+  }
+  const diagnostic = mdxSyntaxDiagnostic(error, siteOf, {
+    includedIn: siteOf(error.line).file === page.sourcePath ? undefined : page.name,
+    severity: "error"
+  });
+  return {
+    column: diagnostic.column,
+    diagnostic,
+    file: diagnostic.file ?? page.sourcePath,
+    line: diagnostic.line ?? 1
+  };
+};
+
+// src/core/meta-diagnostics.ts
+import { readFile as readFile2 } from "node:fs/promises";
+var groupPathOf = (key, versionDirs, localeDirs) => {
+  const parts = key.split("/");
+  if (versionDirs.has(parts[0] ?? "")) {
+    parts.shift();
+  }
+  if (localeDirs.has(parts[0] ?? "")) {
+    parts.shift();
+  }
+  return parts.join("/");
+};
+var likelyChild = (entry, children) => {
+  const key = pageKey(entry);
+  return key !== entry && children.has(key) ? key : closestMatch(entry, [...children]);
+};
+var SLUG_HINT = "List each child by its slug: the file or folder name without its extension, numeric prefix, or parentheses.";
+var unknownPageDiagnostics = async (file, pages, group, children) => {
+  const unknown = pages.flatMap((entry, index) => children.has(entry) ? [] : [{ entry, index }]);
+  if (unknown.length === 0) {
+    return [];
+  }
+  const source = await readFile2(file, "utf-8");
+  const where = group ? `"${group}"` : "the content root";
+  return unknown.map(({ entry, index }) => {
+    const position = locatePath(source, ["pages", index]);
+    const match = likelyChild(entry, children);
+    return {
+      code: "BLUME_META_UNKNOWN_PAGE",
+      column: position?.column,
+      file,
+      line: position?.line,
+      message: `pages lists "${entry}", but no page or folder in ${where} has that slug, so the entry orders nothing.`,
+      severity: "warning",
+      suggestion: match ? `Did you mean "${match}"? ${SLUG_HINT}` : SLUG_HINT
+    };
+  });
+};
+var unreadDiagnostic = ({ dir, file }, group) => ({
+  code: "BLUME_META_OUTSIDE_INCLUDE",
+  file,
+  message: `This meta file is in the "${group}" sidebar group's folder, but no include glob of its content source reaches that folder, so Blume doesn't read it.`,
+  severity: "warning",
+  suggestion: `Add an include glob that reaches the folder, such as "${dir}/**/*.{md,mdx}".`
+});
+var folderMetaDiagnostics = async (discovered, pages, options = {}) => {
+  const children = folderChildKeys(pages.map((page) => page.navPath));
+  const versionDirs = new Set(options.versionDirs);
+  const localeDirs = new Set(options.localeDirs);
+  const groupOf = (key) => groupPathOf(key, versionDirs, localeDirs);
+  const listed = await Promise.all([...discovered.meta, ...discovered.shared].flatMap(([key, meta]) => {
+    const file = discovered.files.get(meta);
+    const group = groupOf(key);
+    return file && meta.pages ? [
+      unknownPageDiagnostics(file, meta.pages, group, children.get(group) ?? new Set)
+    ] : [];
+  }));
+  const unread = discovered.unread.flatMap((entry) => {
+    const group = groupOf(entry.key);
+    return children.has(group) ? [unreadDiagnostic(entry, group)] : [];
+  });
+  return [...listed.flat(), ...unread];
+};
+
 // src/core/meta.ts
 import { basename, dirname, relative as relative2 } from "pathe";
 import { glob, isDynamicPattern } from "tinyglobby";
@@ -921,19 +1475,21 @@ var globBase = (pattern) => {
 };
 var onPathOf = (dir, base) => dir === base || base === "" || dir === "" || dir.startsWith(`${base}/`) || base.startsWith(`${dir}/`);
 var withinInclude = (dir, include) => include === undefined || include.some((pattern) => !pattern.startsWith("!") && onPathOf(dir, globBase(pattern)));
+var globFolderMetaFiles = (source, patterns) => glob([...patterns], {
+  absolute: true,
+  cwd: source.root,
+  ignore: [
+    ...source.exclude ?? [],
+    "**/node_modules/**",
+    "**/.blume/**",
+    "**/dist/**"
+  ],
+  onlyFiles: true
+});
+var isReadMetaFile = (source, file) => withinInclude(relative2(source.root, dirname(file)), source.include);
 var findFolderMetaFiles = async (source, patterns = META_FILES) => {
-  const found = await glob([...patterns], {
-    absolute: true,
-    cwd: source.root,
-    ignore: [
-      ...source.exclude ?? [],
-      "**/node_modules/**",
-      "**/.blume/**",
-      "**/dist/**"
-    ],
-    onlyFiles: true
-  });
-  return found.filter((file) => withinInclude(relative2(source.root, dirname(file)), source.include));
+  const found = await globFolderMetaFiles(source, patterns);
+  return found.filter((file) => isReadMetaFile(source, file));
 };
 var metaKeyFor = (prefix, dir) => {
   const clean = prefix ? trimChar(prefix, "/") : "";
@@ -949,10 +1505,31 @@ var discoverFolderMeta = async (sources, options = {}) => {
   const load = createModuleLoader();
   const meta = new Map;
   const shared = new Map;
+  const files = new Map;
+  const unread = [];
   const diagnostics = [];
+  const keyOf = (source, file) => {
+    const dir = relative2(source.root, dirname(file));
+    const [head, ...tail] = dir.split("/");
+    const version = head && versionDirs.has(head) ? head : "";
+    const afterVersion = version ? tail : [head ?? "", ...tail];
+    const [localeHead, ...localeTail] = afterVersion;
+    const locale = localeHead ? localeDirs.get(localeHead.toLowerCase()) ?? "" : "";
+    const rest = (locale ? localeTail : afterVersion).filter(Boolean).join("/");
+    return [version, locale, metaKeyFor(source.prefix, rest)].filter(Boolean).join("/");
+  };
   const perSource = await Promise.all(list.map(async (source) => {
-    const files = await findFolderMetaFiles(source);
-    const loaded = await Promise.all(files.map(async (file) => {
+    const found = await globFolderMetaFiles(source, META_FILES);
+    for (const file of found) {
+      if (!isReadMetaFile(source, file)) {
+        unread.push({
+          dir: relative2(source.root, dirname(file)),
+          file,
+          key: keyOf(source, file)
+        });
+      }
+    }
+    const loaded = await Promise.all(found.filter((file) => isReadMetaFile(source, file)).map(async (file) => {
       try {
         return {
           file,
@@ -967,14 +1544,7 @@ var discoverFolderMeta = async (sources, options = {}) => {
   }));
   for (const { loaded, source } of perSource) {
     for (const entry of loaded) {
-      const dir = relative2(source.root, dirname(entry.file));
-      const [head, ...tail] = dir.split("/");
-      const version = head && versionDirs.has(head) ? head : "";
-      const afterVersion = version ? tail : [head ?? "", ...tail];
-      const [localeHead, ...localeTail] = afterVersion;
-      const locale = localeHead ? localeDirs.get(localeHead.toLowerCase()) ?? "" : "";
-      const rest = (locale ? localeTail : afterVersion).filter(Boolean).join("/");
-      const key = [version, locale, metaKeyFor(source.prefix, rest)].filter(Boolean).join("/");
+      const key = keyOf(source, entry.file);
       if (!entry.ok) {
         diagnostics.push({
           code: "BLUME_META_LOAD_FAILED",
@@ -988,6 +1558,7 @@ var discoverFolderMeta = async (sources, options = {}) => {
       if (result.success) {
         const target = basename(entry.file).startsWith("meta.$.") ? shared : meta;
         target.set(key, result.data);
+        files.set(result.data, entry.file);
       } else {
         diagnostics.push(...diagnosticsFromZod(result.error, {
           code: "BLUME_META_INVALID",
@@ -996,7 +1567,32 @@ var discoverFolderMeta = async (sources, options = {}) => {
       }
     }
   }
-  return { diagnostics, meta, shared };
+  const read = new Set(perSource.flatMap(({ loaded }) => loaded.map((entry) => entry.file)));
+  return {
+    diagnostics,
+    files,
+    meta,
+    shared,
+    unread: unread.filter((entry) => !read.has(entry.file))
+  };
+};
+var withGeneratedFolderMeta = (user, generated, localeDirs = []) => {
+  const locales = new Set(localeDirs);
+  const beneath = (key, meta) => {
+    const [head, ...rest] = key.split("/");
+    const generatedMeta = generated.get(head !== undefined && locales.has(head) ? rest.join("/") : key);
+    return generatedMeta ? { ...generatedMeta, ...meta } : meta;
+  };
+  return {
+    meta: new Map([...user.meta].map(([key, meta]) => [key, beneath(key, meta)])),
+    shared: new Map([
+      ...generated,
+      ...[...user.shared].map(([key, meta]) => [
+        key,
+        { ...generated.get(key), ...meta }
+      ])
+    ])
+  };
 };
 
 // src/core/sources/resolve.ts
@@ -1390,7 +1986,7 @@ var contentfulSource = (options, ctx) => {
 
 // src/core/sources/filesystem.ts
 import { existsSync, watch as fsWatch } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 import { YAMLException } from "js-yaml";
 import { extname, isAbsolute, join as join2, relative as relative3, resolve } from "pathe";
 import { glob as glob2 } from "tinyglobby";
@@ -1415,7 +2011,7 @@ var filesystemSource = (options) => {
       }
     }
     const read = await Promise.all(loadable.map(async (file) => {
-      const source = await readFile(file, "utf-8");
+      const source = await readFile3(file, "utf-8");
       const ext = extname(file).toLowerCase();
       const format = ext === ".mdx" ? "mdx" : "md";
       let parsed;
@@ -1474,7 +2070,7 @@ var filesystemSource = (options) => {
     load,
     name: options.name,
     prefix: options.prefix,
-    read: (ref) => readFile(join2(contentRoot, ref), "utf-8"),
+    read: (ref) => readFile3(join2(contentRoot, ref), "utf-8"),
     staged: false,
     validate,
     watch
@@ -1735,19 +2331,13 @@ var includeMatcher = (include) => {
   return (ref) => included(ref) && !excluded(ref);
 };
 var GITHUB_HOSTS = new Set(["api.github.com", "raw.githubusercontent.com"]);
+var isGithubUrl = (url) => URL.canParse(url) && GITHUB_HOSTS.has(new URL(url).hostname);
 var githubHeaders2 = (url) => {
   const token = process.env.GITHUB_TOKEN;
-  if (!token) {
-    return {};
-  }
-  let host = "";
-  try {
-    host = new URL(url).hostname;
-  } catch {
-    return {};
-  }
-  return GITHUB_HOSTS.has(host) ? { authorization: `Bearer ${token}` } : {};
+  return token && isGithubUrl(url) ? { authorization: `Bearer ${token}` } : {};
 };
+var TOKEN_STATUSES = new Set([401, 403, 404]);
+var statusReason = (url, status) => TOKEN_STATUSES.has(status) && !process.env.GITHUB_TOKEN && isGithubUrl(url) ? `${url} -> ${status}; GITHUB_TOKEN is not set, which a private repository needs` : `${url} -> ${status}`;
 var fetchText = async (url, doFetch) => {
   try {
     const res = await doFetch(url, {
@@ -1755,7 +2345,7 @@ var fetchText = async (url, doFetch) => {
       signal: AbortSignal.timeout(REMOTE_TIMEOUT_MS)
     });
     if (!res.ok) {
-      throw new Error(`${url} -> ${res.status}`);
+      throw new Error(statusReason(url, res.status));
     }
     return await res.text();
   } catch (error) {
@@ -1797,6 +2387,24 @@ var enumerateGithub = async (github, include, doFetch) => {
     truncated
   };
 };
+var ATX_HEADING = /^ {0,3}#/u;
+var withoutTitleHeading = (page) => {
+  const lines = page.body.split(`
+`);
+  const start = lines.findIndex((line) => line.trim() !== "");
+  const span = ATX_HEADING.test(lines[start] ?? "") ? 1 : 2;
+  const [heading] = start === -1 ? [] : extractHeadings(lines.slice(start, start + span).join(`
+`));
+  if (heading?.depth !== 1 || heading.text === "" || page.data.title !== undefined && page.data.title !== heading.text) {
+    return page;
+  }
+  lines.fill("", start, start + span);
+  return {
+    body: lines.join(`
+`),
+    data: { ...page.data, title: heading.text }
+  };
+};
 var mdxRemoteSource = (options, ctx) => {
   const doFetch = options.fetchImpl ?? globalThis.fetch;
   const cache = snapshotCache(ctx.cacheDir);
@@ -1824,12 +2432,16 @@ var mdxRemoteSource = (options, ctx) => {
     const text = await fetchText(item.fetchUrl, doFetch);
     const parsed = frontmatter_default(text);
     const format = item.ref.toLowerCase().endsWith(".mdx") ? "mdx" : "md";
+    const page = withoutTitleHeading({
+      body: parsed.content,
+      data: parsed.data
+    });
     return {
-      body: { format, text: parsed.content },
-      data: parsed.data,
+      body: { format, text: page.body },
+      data: page.data,
       editUrl: item.editUrl,
       hash: hashText(text),
-      raw: text,
+      raw: text.slice(0, text.length - parsed.content.length) + page.body,
       ref: item.ref
     };
   };
@@ -2140,7 +2752,7 @@ var FRAME_ESCAPED = /\\(?=[<>])/gu;
 var YOUTUBE_HOST = /(?:^|\.)(?:youtube(?:-nocookie)?\.com|youtu\.be)$/u;
 var isYouTubeUrl = (url) => {
   const host = URL.parse(url)?.hostname ?? "";
-  return YOUTUBE_HOST.test(host) && parseYouTubeId(url) !== null;
+  return YOUTUBE_HOST.test(host) && youtubeEmbedSrc(url) !== null;
 };
 var renderVideo = (data) => {
   const url = data.external?.url ?? data.file?.url;
@@ -2425,7 +3037,7 @@ ${nested}`;
 
 // src/core/sources/obsidian.ts
 import { existsSync as existsSync2, watch as fsWatch2, statSync } from "node:fs";
-import { readdir as readdir2, readFile as readFile2, stat } from "node:fs/promises";
+import { readdir as readdir2, readFile as readFile4, stat } from "node:fs/promises";
 import { YAMLException as YAMLException2 } from "js-yaml";
 import { basename as basename2, isAbsolute as isAbsolute2, join as join5, relative as relative4, resolve as resolve2 } from "pathe";
 var MARKDOWN_FILE = /\.md$/iu;
@@ -2443,7 +3055,6 @@ var OBSIDIAN_NATIVE_KEYS = new Set([
   "tag",
   "tags"
 ]);
-var PAGE_META_KEYS = new Set(pageMetaSchema.keyof().options);
 var entrySlugFor = (navPath) => slugifyPath(navPath.replace(MARKDOWN_FILE, ""));
 var noTargets = () => ({
   ambiguous: [],
@@ -2726,7 +3337,7 @@ var noteToEntry = (pair, index, options, unresolved) => {
   const { note } = pair;
   const title = titleFor(note.rel, note.data.title);
   const keep = keptKeysFor(note.data, options);
-  const data = Object.fromEntries(Object.entries(note.data).filter(([key]) => !OBSIDIAN_NATIVE_KEYS.has(key) && (PAGE_META_KEYS.has(key) || keep.has(key))));
+  const data = Object.fromEntries(Object.entries(note.data).filter(([key]) => !OBSIDIAN_NATIVE_KEYS.has(key) && (BUILT_IN_PAGE_META_KEYS.has(key) || keep.has(key))));
   const merged = title === undefined ? data : { ...data, title };
   const body = note.content.trim();
   const text = transformBody(body, index, pair.self, unresolved);
@@ -2748,7 +3359,7 @@ var noteToEntry = (pair, index, options, unresolved) => {
 var readNote = async (vaultDir, rel, options) => {
   const absPath = join5(vaultDir, rel);
   try {
-    const file = await readFile2(absPath, "utf-8");
+    const file = await readFile4(absPath, "utf-8");
     const { content, data } = frontmatter_default(file);
     return {
       absPath,
@@ -2877,7 +3488,7 @@ var obsidianSource = (options, ctx) => {
         suggestion: "Reference notes by their vault-relative path."
       });
     }
-    return await readFile2(absPath, "utf-8");
+    return await readFile4(absPath, "utf-8");
   };
   const validate = () => {
     const stats = statSync(vaultDir, { throwIfNoEntry: false });
@@ -3593,6 +4204,284 @@ var resolveSources = (config, context, runtime) => {
   return sources;
 };
 
+// src/core/svg-images.ts
+import { readFile as readFile5 } from "node:fs/promises";
+import { imageMetadata } from "astro/assets/utils";
+import { dirname as dirname2, extname as extname3 } from "pathe";
+var isUnmeasurableSvg = async (path) => {
+  if (extname3(path).toLowerCase() !== ".svg") {
+    return false;
+  }
+  let data;
+  try {
+    data = await readFile5(path);
+  } catch {
+    return false;
+  }
+  try {
+    await imageMetadata(data, path);
+    return false;
+  } catch {
+    return true;
+  }
+};
+var unmeasurableSvgDiagnostics = async (pages) => {
+  const seen = new Set;
+  const embeds = pages.flatMap((page) => {
+    const { sourcePath } = page;
+    if (!sourcePath) {
+      return [];
+    }
+    return page.links.flatMap((link) => {
+      const file = link.file ?? sourcePath;
+      const key = `${file}:${link.line}:${link.column}`;
+      if (!link.image || seen.has(key)) {
+        return [];
+      }
+      seen.add(key);
+      const abs = resolveRelativeImage(dirname2(sourcePath), link.target);
+      return abs ? [{ abs, file, link }] : [];
+    });
+  });
+  const found = await Promise.all(embeds.map(async (embed) => await isUnmeasurableSvg(embed.abs) ? [embed] : []));
+  return found.flat().map(({ file, link }) => ({
+    code: "BLUME_SVG_UNOPTIMIZED",
+    column: link.column,
+    file,
+    line: link.line,
+    message: `\`${link.target}\` is served as it is, not optimized: Astro can't read its size, which takes the whole \`<svg>\` tag within the file's first 1,000 bytes, with a width and height or a viewBox.`,
+    severity: "warning",
+    suggestion: "The image still shows. To have it optimized, put the `<svg>` tag's width and height (or viewBox) near the start of the file. In a draw.io export, the `content` attribute pushes them out: export without a copy of the diagram, or remove that attribute."
+  }));
+};
+
+// src/core/syntax-diagnostics.ts
+import { slug } from "github-slugger";
+import { markdownToMdast as markdownToMdast4 } from "satteri";
+var UNESCAPED = String.raw`(?<=(?:^|[^\\])(?:\\\\)*)`;
+var TEMPLATE_TAG = new RegExp(String.raw`${UNESCAPED}\{%[^\n]*?%\}`, "gu");
+var TEMPLATE_OUTPUT = new RegExp(String.raw`${UNESCAPED}\{\{(?<expression>[^\n{}]*)\}\}`, "gu");
+var VARIABLE_REFERENCE = /^\s*[\w-]+\s*$/u;
+var WIKILINK2 = /(?<![!\\[])\[\[(?<inner>[^[\]\n]+)\]\](?![([:])/gu;
+var MDC_BLOCK = /^[\t ]*(?<written>::(?<name>[a-z][\w-]*)(?:\[[^\]\n]*\])?(?:\{[^}\n]*\})?)[\t ]*$/gimu;
+var MDC_INLINE = /(?<![\w:\\])(?<written>:{1,2}(?<name>[a-z][\w-]*)(?:\[[^\]\n]*\](?:\{[^}\n]*\})?|\{[^}\n]*\}))/giu;
+var ATTRIBUTE_LIST = new RegExp(String.raw`(?<![=\\])\{:?[\t ]*${ATTRIBUTE}(?:[\t ]+${ATTRIBUTE})*[\t ]*\}`, "gu");
+var DIRECTIVE_ATTRIBUTES = /:+[a-z][\w-]*(?:\[[^\]\n]*\])?\{[^}\n]*\}/giu;
+var ATX_HEADING2 = /^ {0,3}#{1,6}[\t ]/u;
+var SETEXT_UNDERLINE = /^ {0,3}(?:=+|-+)[\t ]*$/u;
+var VOID_ELEMENT = new RegExp(String.raw`${UNESCAPED}<(?<tag>area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)(?=[\s/>])(?:[^<>"'/]|"[^"]*"|'[^']*'|\/(?!>))*>`, "gu");
+var SUSPECT_WIKILINK = /\[\[/u;
+var SUSPECT_MDC = /(?:^|[^\w:]):{1,2}[a-z][\w-]*[[{]|^[\t ]*::[a-z]/imu;
+var MDX_COMMENT = /\{\s*\/\*[\s\S]*?\*\/\s*\}/gu;
+var ANGLE_DESTINATION = /(?<=\]\([\t ]*|^ {0,3}\[[^\]\n]+\]:[\t ]*)<[^<>\n]*>/gmu;
+var blank = (text) => text.replaceAll(/[^\n]/gu, " ");
+var maskMarkdown = (text) => {
+  const ranges = [];
+  const walk = (node) => {
+    const start = node.position?.start.offset ?? 0;
+    const end = node.position?.end.offset ?? start;
+    if (node.type === "code" || node.type === "inlineCode" || node.type === "html" && node.value.startsWith("<!--")) {
+      ranges.push([start, end]);
+    } else if ("children" in node) {
+      for (const child of node.children) {
+        walk(child);
+      }
+    }
+  };
+  walk(markdownToMdast4(text, {
+    features: { ...MARKDOWN_BODY_FEATURES, gfm: true }
+  }));
+  let masked = "";
+  let cursor = 0;
+  for (const [start, end] of ranges) {
+    masked += text.slice(cursor, start) + blank(text.slice(start, end));
+    cursor = end;
+  }
+  return masked + text.slice(cursor);
+};
+var maskMdx = (text) => {
+  let fence = null;
+  return text.split(`
+`).map((line) => {
+    const next = nextFenceState(line, fence);
+    const inFence = fence !== null || next !== null;
+    fence = next;
+    return inFence ? blank(line) : line.replaceAll(INLINE_CODE, blank);
+  }).join(`
+`).replaceAll(MDX_COMMENT, blank).replaceAll(HTML_COMMENT, blank).replaceAll(ANGLE_DESTINATION, blank);
+};
+var lineStartsOf = (text) => {
+  const starts = [0];
+  for (let index = text.indexOf(`
+`);index !== -1; index = text.indexOf(`
+`, index + 1)) {
+    starts.push(index + 1);
+  }
+  return starts;
+};
+var siteOf = (starts, at) => {
+  const line = starts.findLastIndex((start) => start <= at);
+  return { column: at - (starts[line] ?? 0) + 1, line: line + 1 };
+};
+var templateFindings = ({ starts, text }) => [
+  ...[...text.matchAll(TEMPLATE_TAG)].map((match) => ({
+    ...siteOf(starts, match.index),
+    code: "BLUME_TEMPLATE_TAG",
+    message: `\`${match[0]}\` is a Liquid or Markdoc tag, which Blume doesn't run, so the page shows it as written.`,
+    suggestion: "Rewrite what it produced as Markdown or a Blume component, or remove it. To show it as text, put it in inline code."
+  })),
+  ...[...text.matchAll(TEMPLATE_OUTPUT)].filter((match) => !VARIABLE_REFERENCE.test(match.groups?.expression ?? "")).map((match) => ({
+    ...siteOf(starts, match.index),
+    code: "BLUME_TEMPLATE_TAG",
+    message: `\`${match[0]}\` is a Liquid output tag, which Blume doesn't fill in, so the page shows it as written.`,
+    suggestion: "Write the value in its place, or define it under `variables` in blume.config.ts and write `{{name}}`. To show it as text, put it in inline code."
+  }))
+];
+var wikiKey = (name) => name.trim().toLowerCase().replaceAll(/[\s_-]+/gu, "-");
+var indexPageNames = (pages) => {
+  const index = new Map;
+  for (const page of pages) {
+    const stem = (page.source.ref.split("/").at(-1) ?? "").replace(/\.mdx?$/iu, "");
+    for (const key of new Set([wikiKey(stem), wikiKey(page.title)])) {
+      const named = index.get(key);
+      if (named) {
+        named.push(page);
+      } else {
+        index.set(key, [page]);
+      }
+    }
+  }
+  return index;
+};
+var partRoute = (text, pageRoute) => {
+  const [name = "", heading] = text.split("#", 2);
+  const route = pageRoute(name);
+  return route && heading ? `${route}#${slug(heading)}` : route;
+};
+var wikilinkFindings = ({ pageRoute, starts, text }) => [...text.matchAll(WIKILINK2)].flatMap((match) => {
+  const parts = (match.groups?.inner ?? "").split("|").map((part) => ({
+    route: partRoute(part, pageRoute),
+    text: part.trim()
+  }));
+  const target = parts.find((part) => part.route !== undefined);
+  if (!target && parts.length === 1) {
+    return [];
+  }
+  const label = parts.find((part) => part !== target) ?? target;
+  return [
+    {
+      ...siteOf(starts, match.index),
+      code: "BLUME_WIKILINK_UNSUPPORTED",
+      message: `\`${match[0]}\` is a wiki link, which Blume reads only in an Obsidian vault source, so the page shows it as written${target ? ` instead of linking to ${target.route}` : ""}.`,
+      suggestion: target ? `Rewrite it as a Markdown link: \`[${label?.text}](${target.route})\`.` : "Rewrite it as a Markdown link to the page, like `[Text](./page.md)`."
+    }
+  ];
+});
+var mdcFindings = ({ starts, text }) => {
+  const blocks = [...text.matchAll(MDC_BLOCK)].map((match) => ({
+    at: match.index + match[0].indexOf("::"),
+    written: match.groups?.written
+  }));
+  const opened = new Set(blocks.map(({ at }) => at));
+  return [
+    ...blocks.map(({ at, written }) => ({
+      ...siteOf(starts, at),
+      code: "BLUME_MDC_SYNTAX",
+      message: `\`${written}\` opens a Nuxt Content (MDC) block component, which Blume doesn't render, so the page shows its \`::\` lines as text.`,
+      suggestion: "Rewrite the block as the matching Blume component (`<Callout>`, `<Card>`, `<Tabs>`, …) or a `:::` callout."
+    })),
+    ...[...text.matchAll(MDC_INLINE)].filter((match) => !opened.has(match.index)).map((match) => ({
+      ...siteOf(starts, match.index),
+      code: "BLUME_MDC_SYNTAX",
+      message: `\`${match.groups?.written}\` is an inline component in Nuxt Content (MDC) syntax, which Blume doesn't render, so the page shows it as written.`,
+      suggestion: "Rewrite it as the matching Blume component (`<Badge>`, `<Icon>`, …) or as plain text."
+    }))
+  ];
+};
+var isHeadingMarker = (lines, site, written, format) => {
+  const line = lines[site.line - 1] ?? "";
+  const heading = ATX_HEADING2.test(line) || SETEXT_UNDERLINE.test(lines[site.line] ?? "");
+  const marker = trailingCurlyMarker(line);
+  return heading && marker?.marker === written && marker.index === site.column - 1 && (format === "md" || !marker.attributes);
+};
+var ATTRIBUTE_LIST_PROBLEMS = {
+  md: {
+    code: "BLUME_MD_ATTRIBUTE_LIST",
+    effect: "which Blume doesn't read, so the page shows it as written",
+    suggestion: 'Remove it. To keep the attributes, write the element as HTML (`<img src="…" width="300">`), or pin a heading\'s anchor with `[#id]`. To show the braces as text, put them in inline code.'
+  },
+  mdx: {
+    code: "BLUME_MDX_ATTRIBUTE_LIST",
+    effect: "which MDX reads as a JavaScript expression, so the page fails to build",
+    suggestion: 'Remove it. To keep the attributes, write the element as JSX (`<img src="…" width="300" />`), or pin a heading\'s anchor with `[#id]`. To show the braces as text, escape them: `\\{…\\}`.'
+  }
+};
+var attributeListFindings = (format) => ({ starts, text }) => {
+  const { code, effect, suggestion } = ATTRIBUTE_LIST_PROBLEMS[format];
+  const scanned = text.replaceAll(DIRECTIVE_ATTRIBUTES, blank).replaceAll(TEMPLATE_OUTPUT, blank);
+  const lines = text.split(`
+`);
+  return [...scanned.matchAll(ATTRIBUTE_LIST)].map((match) => ({
+    site: siteOf(starts, match.index),
+    written: match[0]
+  })).filter(({ site, written }) => !isHeadingMarker(lines, site, written, format)).map(({ site, written }) => ({
+    ...site,
+    code,
+    message: `\`${written}\` is an attribute list, ${effect}.`,
+    suggestion
+  }));
+};
+var SUSPECT_ATTRIBUTE_LIST = /\{:?[\t ]*(?:[#.][A-Za-z_-]|[\w-]+=)/u;
+var voidElementFindings = ({ starts, text }) => [...text.matchAll(VOID_ELEMENT)].filter((match) => !text.slice(match.index + match[0].length).trimStart().startsWith(`</${match.groups?.tag}>`)).map((match) => ({
+  ...siteOf(starts, match.index),
+  code: "BLUME_MDX_UNCLOSED_ELEMENT",
+  message: `\`<${match.groups?.tag}>\` isn't closed. MDX reads HTML as JSX, where it needs \`/>\`: unclosed, it fails the page, or in an included file it takes in everything after it.`,
+  suggestion: `Close it: \`<${match.groups?.tag} … />\`.`
+}));
+var CHECKS = {
+  md: [
+    { find: templateFindings, suspect: /\{[%{]/u },
+    { find: wikilinkFindings, suspect: SUSPECT_WIKILINK },
+    { find: mdcFindings, suspect: SUSPECT_MDC },
+    { find: attributeListFindings("md"), suspect: SUSPECT_ATTRIBUTE_LIST }
+  ],
+  mdx: [
+    { find: wikilinkFindings, suspect: SUSPECT_WIKILINK },
+    { find: mdcFindings, suspect: SUSPECT_MDC },
+    { find: attributeListFindings("mdx"), suspect: SUSPECT_ATTRIBUTE_LIST },
+    {
+      find: voidElementFindings,
+      suspect: /<(?:area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)[\s/>]/u
+    }
+  ]
+};
+var syntaxFindings = (text, format, pageRoute) => {
+  const checks = CHECKS[format].filter((check) => check.suspect.test(text));
+  if (checks.length === 0) {
+    return [];
+  }
+  const masked = format === "mdx" ? maskMdx(text) : maskMarkdown(text);
+  const scan = { pageRoute, starts: lineStartsOf(masked), text: masked };
+  return checks.flatMap((check) => check.find(scan)).toSorted((a, b) => a.line - b.line || a.column - b.column);
+};
+var syntaxDiagnostics = (entry, sourceName, pages = new Map, locale = "") => {
+  const page = entry.sourcePath ?? `${sourceName}:${entry.ref}`;
+  const offset = entry.bodyLineOffset ?? strippedLineOffset(entry.raw, entry.body.text);
+  const pageRoute = (name) => {
+    const named = pages.get(wikiKey(name));
+    return (named?.find((other) => other.locale === locale) ?? named?.[0])?.route;
+  };
+  return syntaxFindings(entry.expanded?.text ?? entry.body.text, entry.body.format, pageRoute).map(({ line, ...finding }) => {
+    const origin = entry.expanded?.origins[line - 1];
+    return {
+      ...finding,
+      file: origin?.file ?? page,
+      line: origin?.line ?? line + offset,
+      severity: "warning"
+    };
+  });
+};
+
 // src/core/project-graph.ts
 var isWithin = (dir, path) => {
   const rel = relative5(dir, path);
@@ -3631,16 +4520,25 @@ var entryIdDiagnostics = (pages, collectionBase) => {
   }
   return diagnostics;
 };
-var normalizeLoadedEntries = (loaded, config) => {
+var normalizeLoadedEntries = (loaded, config, dropUnparsable) => {
   const frontmatterExtend = Object.keys(config.frontmatter.extend).length > 0 ? config.frontmatter.extend : undefined;
   const declaredTypes = Object.entries(config.content.types).filter(([, type]) => Object.keys(type.frontmatter).length > 0);
   const typeFrontmatter = declaredTypes.length > 0 ? Object.fromEntries(declaredTypes.map(([name, type]) => [name, type.frontmatter])) : undefined;
   const pages = [];
   const allDiagnostics = [];
+  const syntaxErrors = [];
+  const unparsable = [];
+  const published = [];
   let droppedPages = 0;
   for (const { source, entries, diagnostics } of loaded) {
     allDiagnostics.push(...diagnostics);
     for (const entry of entries) {
+      const syntax = mdxSyntaxCheck(entry, source.name, config.variables);
+      syntaxErrors.push(...syntax.diagnostics);
+      const drop = syntax.unparsable && dropUnparsable;
+      if (drop && entry.sourcePath && !source.staged) {
+        unparsable.push(entry.sourcePath);
+      }
       const normalized = normalizeEntry(entry, {
         basePath: config.basePath,
         defaultType: config.content.defaultType,
@@ -3656,17 +4554,27 @@ var normalizeLoadedEntries = (loaded, config) => {
         typeFrontmatter,
         versions: config.versions
       });
-      if (normalized.pages.length === 0 && normalized.diagnostics.length > 0) {
+      const [page] = normalized.pages;
+      if (page ? drop : normalized.diagnostics.length > 0) {
         droppedPages += 1;
       }
-      pages.push(...normalized.pages);
+      if (!drop) {
+        pages.push(...normalized.pages);
+      }
       allDiagnostics.push(...normalized.diagnostics);
-      if (normalized.pages.length > 0) {
-        allDiagnostics.push(...unknownDirectiveDiagnostics(entry, source.name));
+      if (page) {
+        allDiagnostics.push(...directiveDiagnostics(entry, source.name), ...codeFenceDiagnostics(entry, source.name), ...alertDiagnostics(entry, source.name));
+        published.push({ entry, locale: page.locale, source: source.name });
       }
     }
   }
-  return { diagnostics: allDiagnostics, droppedPages, pages };
+  const names = indexPageNames(pages);
+  for (const { entry, locale, source } of published) {
+    allDiagnostics.push(...syntaxDiagnostics(entry, source, names, locale));
+  }
+  const covered = (diagnostic) => allDiagnostics.some((other) => other.file === diagnostic.file && other.line === diagnostic.line && (other.severity === "error" || other.severity === "warning" && diagnostic.severity === "warning"));
+  allDiagnostics.push(...syntaxErrors.filter((error) => !covered(error)));
+  return { diagnostics: allDiagnostics, droppedPages, pages, unparsable };
 };
 var gitContentRoots = (sources, gitRoot) => {
   if (gitRoot === null) {
@@ -3701,19 +4609,31 @@ var substituteEntryVariables = (entry, variables) => {
   return diagnostics;
 };
 var substituteLoadedVariables = (loaded, variables) => hasVariables(variables) ? loaded.flatMap(({ entries }) => entries.flatMap((entry) => substituteEntryVariables(entry, variables))) : [];
-var redirectPageDiagnostics = (config, pages, configFile) => config.redirects.flatMap((redirect) => {
+var redirectPageDiagnostics = (config, pages, mirrored, configFile) => config.redirects.flatMap((redirect) => {
   const from = withBasePath(config.basePath, redirect.from);
   if (!isPatternPath(redirect.from)) {
     const page = normalizePath(from);
-    return pages.includes(page) ? [
+    if (pages.includes(page)) {
+      return [
+        {
+          code: "BLUME_REDIRECT_MATCHES_PAGE",
+          file: configFile ?? undefined,
+          message: `The redirect from ${redirect.from} is also the page ${page}, which never publishes: its URL redirects to ${redirect.to} instead.`,
+          severity: "warning",
+          suggestion: "If the page moved, delete it or give it a new slug; otherwise remove the redirect."
+        }
+      ];
+    }
+    const owner = mirroredPage(mirrored, page);
+    return owner === undefined ? [] : [
       {
         code: "BLUME_REDIRECT_MATCHES_PAGE",
         file: configFile ?? undefined,
-        message: `The redirect from ${redirect.from} is also the page ${page}, which never publishes: its URL redirects to ${redirect.to} instead.`,
+        message: `The redirect from ${redirect.from} is also the Markdown copy of the page ${owner}, so that copy never publishes: its URL redirects to ${redirect.to} instead.`,
         severity: "warning",
-        suggestion: "If the page moved, delete it or give it a new slug; otherwise remove the redirect."
+        suggestion: "Remove the redirect: that URL serves the page's Markdown to agents."
       }
-    ] : [];
+    ];
   }
   const matched = pathsUnderPattern(from, pages);
   const [first] = matched;
@@ -3731,6 +4651,43 @@ var redirectPageDiagnostics = (config, pages, configFile) => config.redirects.fl
     }
   ];
 });
+var withSourceRedirects = (config, loaded, pages) => {
+  const requested = loaded.flatMap(({ redirects }) => redirects ?? []);
+  if (requested.length === 0) {
+    return config;
+  }
+  const served = (route) => normalizePath(withBasePath(config.basePath, route));
+  const prefixes = [
+    "",
+    ...config.i18n?.locales.map((locale) => `/${locale.code}`) ?? []
+  ];
+  const taken = new Set(config.redirects.map((redirect) => served(redirect.from)));
+  const added = [];
+  for (const redirect of requested) {
+    for (const prefix of prefixes) {
+      const from = `${prefix}${redirect.from}`;
+      const to = `${prefix}${redirect.to}`;
+      if (!pages.has(served(to)) || pages.has(served(from)) || taken.has(served(from))) {
+        continue;
+      }
+      taken.add(served(from));
+      added.push({ from, status: 301, to });
+    }
+  }
+  return added.length > 0 ? { ...config, redirects: [...config.redirects, ...added] } : config;
+};
+var publicOpenApiDiagnostics = (config, root) => {
+  const file = join8(root, "public", "openapi.json");
+  return config.agents.api && existsSync3(file) ? [
+    {
+      code: "BLUME_PUBLIC_OPENAPI_JSON",
+      file,
+      message: "public/openapi.json is served at /openapi.json, where Blume publishes the OpenAPI description of the site's JSON docs API, so that description isn't generated, and /.well-known/api-catalog still lists /openapi.json as the docs API's description.",
+      severity: "warning",
+      suggestion: "Move the file to another path, like public/specs/openapi.json, and update what links to it. A spec an openapi() reference renders can live outside public/ altogether. Or set agents.api to false if the site shouldn't publish the JSON docs API."
+    }
+  ] : [];
+};
 var bannerLinkHref = (banner) => banner === undefined || isBannerShorthand(banner) ? undefined : banner.link?.href;
 var validatedSources = (config, context, runtime, beforeSources) => {
   beforeSources?.(config);
@@ -3786,15 +4743,17 @@ var scanProject = async (root, options = {}) => {
     });
   }));
   const variableDiagnostics = substituteLoadedVariables(loaded, config.variables);
-  const sharedFolderMeta = new Map([
-    ...loaded.flatMap(({ folderMeta: sourceMeta }) => Object.entries(sourceMeta ?? {})),
-    ...folderMeta.shared
-  ]);
+  const mergedFolderMeta = withGeneratedFolderMeta(folderMeta, new Map(loaded.flatMap(({ folderMeta: sourceMeta }) => Object.entries(sourceMeta ?? {}))), localeDirs);
   const {
     diagnostics: contentDiagnostics,
     droppedPages,
-    pages: allPages
-  } = normalizeLoadedEntries(loaded, config);
+    pages: allPages,
+    unparsable
+  } = normalizeLoadedEntries(loaded, config, mode === "build");
+  const metaDiagnostics = await folderMetaDiagnostics(folderMeta, allPages, {
+    localeDirs,
+    versionDirs: config.versions?.archived.map((version) => version.id)
+  });
   const pages = mode === "build" && !preview ? allPages.filter((page) => !page.meta.draft) : allPages;
   const lastModified = resolveLastModifiedConfig(config.lastModified);
   const lastModifiedWarnings = [];
@@ -3821,40 +4780,54 @@ var scanProject = async (root, options = {}) => {
     basePath: config.basePath,
     brandHref: logoHref(config.logo),
     extraRoutes,
-    folderMeta: folderMeta.meta,
+    folderMeta: mergedFolderMeta.meta,
     i18n: config.i18n,
     navigation: config.navigation,
-    sharedFolderMeta,
+    sharedFolderMeta: mergedFolderMeta.shared,
     versions: config.versions
   });
   const manifest = buildManifest({ config, context, graph });
   const i18nWarnings = config.i18n ? i18nDiagnostics(pages, config.i18n, config.versions) : [];
+  const svgWarnings = await unmeasurableSvgDiagnostics(pages);
   const versionWarnings = config.versions ? versionsDiagnostics(pages, config.versions) : [];
+  const servedPaths = [
+    ...manifest.routes.map((route) => route.path),
+    ...extraRoutes
+  ];
+  const redirects = [
+    ...config.redirects,
+    ...formerRouteRedirects(pages, new Set(servedPaths), config)
+  ];
   return {
-    config,
+    config: withSourceRedirects(redirects.length === config.redirects.length ? config : { ...config, redirects }, loaded, new Set([...routeSetFor(manifest.routes), ...extraRoutes])),
     context,
     diagnostics: [
+      ...configResult.diagnostics,
       ...contentDiagnostics,
       ...includeDiagnostics,
       ...variableDiagnostics,
       ...folderMeta.diagnostics,
+      ...metaDiagnostics,
       ...entryIdDiagnostics(pages, resolveDocsCollection(config, context.root).base),
       ...graph.diagnostics,
       ...i18nWarnings,
       ...versionWarnings,
       ...lastModifiedWarnings,
-      ...redirectPageDiagnostics(config, [...manifest.routes.map((route) => route.path), ...extraRoutes], context.configFile)
+      ...svgWarnings,
+      ...publicOpenApiDiagnostics(config, context.root),
+      ...redirectPageDiagnostics(config, servedPaths, routeSetFor(manifest.routes), context.configFile)
     ],
     droppedPages,
     graph,
     manifest,
     mode,
     sources,
-    themeFontsConfigured: configResult.themeFontsConfigured
+    themeFontsConfigured: configResult.themeFontsConfigured,
+    unparsable
   };
 };
 
-export { directiveSource, validateSearchPopularIcons, validateNavTargets, contentIndexable, buildManifest, findFolderMetaFiles, isWithin, scanProject };
+export { directiveSource, normalizeFence, QUOTED_ATTR, metaTokens, RESERVED_META_KEYWORDS, isForeignKeyword, isLineRange, validateSearchPopularIcons, validateNavTargets, gitEnv, realPath, gitRepositoryRoot, locateMdxFailure, findFolderMetaFiles, isWithin, scanProject };
 
-//# debugId=D6EC9010B970FDF164756E2164756E21
-//# sourceMappingURL=chunk-0pmb4tr4.js.map
+//# debugId=358E42903E85F0E564756E2164756E21
+//# sourceMappingURL=chunk-8f8xw4x2.js.map