blume 1.2.0 → 1.3.0

package/dist/cli/index.js

@@ -391,8 +391,8 @@ var diagnosticsFromIssues = (issues, options) => issues.map((issue) => {
   };
 });
 var diagnosticsFromZod = (error, options) => diagnosticsFromIssues(error.issues.map((issue) => ({
-  message: "received" in issue ? `${issue.message} (received: ${JSON.stringify(issue.received)})` : issue.message,
-  path: issue.path
+  message: issue.message,
+  path: issue.path.filter((segment) => typeof segment !== "symbol")
 })), options);
 var ESC = String.fromCodePoint(27);
 var COLORS = {
@@ -1180,6 +1180,22 @@ var CHECKS = [
     tier: "static",
     title: "Indexable page missing from llms.txt"
   },
+  {
+    category: "ai",
+    fix: "Publish a ServiceMode SVCB or HTTPS record at `_index._agents.<host>` with your DNS provider so agents can discover the site via DNS (DNS-AID).",
+    id: "BLUME_AUDIT_DNS_AID_MISSING",
+    severity: "info",
+    tier: "network",
+    title: "No DNS-AID agent-discovery records"
+  },
+  {
+    category: "ai",
+    fix: "Enable DNSSEC for the zone so validating resolvers return authenticated DNS-AID answers; if your DNS provider doesn't support DNSSEC, the records still work unsigned.",
+    id: "BLUME_AUDIT_DNS_AID_UNSIGNED",
+    severity: "info",
+    tier: "network",
+    title: "DNS-AID records are not DNSSEC-authenticated"
+  },
   {
     category: "structured-data",
     fix: "The JSON-LD block must be valid JSON.",
@@ -1376,6 +1392,9 @@ var formatReport = (result, root, options = {}) => {
     const shown = options.verbose ? group.findings : group.findings.slice(0, PREVIEW);
     for (const diagnostic of shown) {
       lines.push(findingLine(diagnostic, root));
+      if (options.verbose) {
+        lines.push(`        ${COLORS2.dim}${diagnostic.message}${COLORS2.reset}`);
+      }
     }
     const hidden = group.count - shown.length;
     if (hidden > 0) {
@@ -1831,6 +1850,104 @@ var contentChecks = {
   tier: "static"
 };
 
+// src/audit/checks/dns-aid.ts
+var RR_SVCB = 64;
+var RR_HTTPS = 65;
+var DOH_TIMEOUT_MS = 5000;
+var DOH_RESOLVERS = [
+  "https://dns.google/resolve",
+  "https://cloudflare-dns.com/dns-query"
+];
+var resolvers = () => {
+  const override = process.env.BLUME_DOH_URL;
+  return override ? [override] : DOH_RESOLVERS;
+};
+var fetchDohJson = async (base, name, type, fetchFn) => {
+  try {
+    const response = await fetchFn(`${base}?name=${encodeURIComponent(name)}&type=${type}`, {
+      headers: { accept: "application/dns-json" },
+      signal: AbortSignal.timeout(DOH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    return await response.json();
+  } catch {
+    return null;
+  }
+};
+var queryDoh = async (name, type, fetchFn) => {
+  for (const base of resolvers()) {
+    const response = await fetchDohJson(base, name, type, fetchFn);
+    if (response) {
+      return response;
+    }
+  }
+  return null;
+};
+var lookupDnsAid = async (host, fetchFn = fetch) => {
+  const name = `_index._agents.${host}`;
+  let answered = false;
+  let found = false;
+  let authenticated = true;
+  const responses = await Promise.all([RR_HTTPS, RR_SVCB].map((type) => queryDoh(name, type, fetchFn)));
+  for (const response of responses) {
+    if (!response) {
+      continue;
+    }
+    answered = true;
+    const records = (response.Answer ?? []).filter((answer) => answer.type === RR_SVCB || answer.type === RR_HTTPS);
+    if (records.length > 0) {
+      found = true;
+      authenticated &&= response.AD === true;
+    }
+  }
+  return answered ? { authenticated, found } : null;
+};
+var dnsAidFindings = (host, result) => {
+  if (!result.found) {
+    return [
+      finding("BLUME_AUDIT_DNS_AID_MISSING", { url: "/" }, `No SVCB or HTTPS records at _index._agents.${host} — agents probing DNS for AI Discovery (DNS-AID) find nothing.`, `Publish a ServiceMode record with your DNS provider, e.g. \`_index._agents.${host}. 3600 IN HTTPS 1 ${host}. alpn=h2\`, and sign the zone with DNSSEC if the provider supports it.`)
+    ];
+  }
+  if (!result.authenticated) {
+    return [
+      finding("BLUME_AUDIT_DNS_AID_UNSIGNED", { url: "/" }, `The DNS-AID records at _index._agents.${host} exist but are not DNSSEC-authenticated, so validating resolvers can't prove they're genuine.`)
+    ];
+  }
+  return [];
+};
+var dnsAidHost = (site) => {
+  if (!site) {
+    return null;
+  }
+  let hostname;
+  try {
+    ({ hostname } = new URL(site));
+  } catch {
+    return null;
+  }
+  if (hostname === "localhost" || hostname.endsWith(".local") || !hostname.includes(".")) {
+    return null;
+  }
+  return hostname;
+};
+var dnsAidChecks = {
+  category: "ai",
+  async run(context) {
+    if (!context.origin) {
+      return [];
+    }
+    const host = dnsAidHost(context.project.config.deployment.site);
+    if (!host) {
+      return [];
+    }
+    const result = await lookupDnsAid(host);
+    return result ? dnsAidFindings(host, result) : [];
+  },
+  tier: "network"
+};
+
 // src/audit/checks/duplicates.ts
 var isNonCanonical = (page, deployBase) => {
   if (!page.canonical) {
@@ -3000,31 +3117,6 @@ var askBackendRuntimeDep = (ask) => {
   return ASK_PRESETS[provider]?.runtimeDep ?? OPENAI_COMPATIBLE_DEP;
 };
 
-// src/core/sources/watch.ts
-var BLUME_IGNORE_DIRS = [
-  ".blume",
-  ".blume-verify",
-  ".cache",
-  ".git",
-  ".next",
-  ".turbo",
-  ".vercel",
-  "dist",
-  "node_modules"
-];
-var baselineScanIgnore = () => BLUME_IGNORE_DIRS.map((dir) => `**/${dir}/**`);
-var BLUME_WATCH_IGNORE_DIRS = BLUME_IGNORE_DIRS;
-var excludeDirSegments = (patterns) => patterns.map((pattern) => /^(?<dir>[^*/]+)\/\*\*$/u.exec(pattern)?.groups?.dir).filter((dir) => dir !== undefined);
-var ignoringWatchListener = (onChange, ignoreDirs = BLUME_WATCH_IGNORE_DIRS) => {
-  const ignore = new Set(ignoreDirs);
-  return (_event, filename) => {
-    if (typeof filename === "string" && filename.split(/[/\\]/u).some((segment) => ignore.has(segment))) {
-      return;
-    }
-    onChange();
-  };
-};
-
 // src/core/trim.ts
 var trimStart = (text, char) => {
   let start = 0;
@@ -3042,41 +3134,6 @@ var trimEnd = (text, char) => {
 };
 var trimChar = (text, char) => trimEnd(trimStart(text, char), char);
 
-// src/deploy/redirects.ts
-var applyBaseToAstroRedirects = (redirects, basePath, deployBase) => {
-  const base = normalizeBasePath(deployBase);
-  return basePath || base ? redirects.map((redirect) => ({
-    ...redirect,
-    from: withBasePath(basePath, redirect.from),
-    to: withComposedBasePath(base, basePath, redirect.to)
-  })) : redirects;
-};
-var applyBaseToPlatformRedirects = (redirects, basePath, deployBase) => {
-  const base = normalizeBasePath(deployBase);
-  return basePath || base ? redirects.map((redirect) => ({
-    ...redirect,
-    from: withComposedBasePath(base, basePath, redirect.from),
-    to: withComposedBasePath(base, basePath, redirect.to)
-  })) : redirects;
-};
-var buildNetlifyRedirects = (redirects) => `${redirects.map((redirect) => `${redirect.from} ${redirect.to} ${redirect.status}`).join(`
-`)}
-`;
-var buildVercelConfig = (redirects) => `${JSON.stringify({
-  redirects: redirects.map((redirect) => ({
-    destination: redirect.to,
-    source: redirect.from,
-    statusCode: redirect.status
-  }))
-}, null, 2)}
-`;
-var buildRedirectManifest = (redirects) => `${JSON.stringify(redirects.map((redirect) => ({
-  from: redirect.from,
-  status: redirect.status,
-  to: redirect.to
-})), null, 2)}
-`;
-
 // src/openapi/references.ts
 var NON_SLUG = /[^a-z0-9]+/gu;
 var slugify = (text) => trimChar(text.toLowerCase().replace(NON_SLUG, "-"), "-");
@@ -3176,6 +3233,129 @@ var blumeReferences = (config) => {
 };
 var hasScalarReferences = (config) => resolveReferences(config).some((ref) => ref.renderer === "scalar");
 
+// src/ai/api-catalog.ts
+var API_CATALOG_PATH = "/.well-known/api-catalog";
+var API_CATALOG_TYPE = "application/linkset+json";
+var HTTP_URL = /^https?:\/\//u;
+var linksetEntries = (config) => {
+  const site = config.deployment.site ?? null;
+  const deployBase = normalizeBasePath(config.deployment.base);
+  const abs = (path) => {
+    const based = withBasePath(deployBase, path);
+    return site ? `${trimEnd(site, "/")}${based}` : based;
+  };
+  const entries = [];
+  for (const reference of resolveReferences(config)) {
+    const docRoute = reference.renderer === "blume" ? withBasePath(reference.basePath, reference.route) : reference.route;
+    const entry = {
+      anchor: abs(docRoute),
+      "service-doc": [{ href: abs(docRoute), type: "text/html" }]
+    };
+    if (HTTP_URL.test(reference.spec)) {
+      entry["service-desc"] = [{ href: reference.spec }];
+    }
+    entries.push(entry);
+  }
+  if (config.ai.mcp.enabled) {
+    entries.push({
+      anchor: abs(config.ai.mcp.route),
+      "service-desc": [
+        { href: abs("/.well-known/mcp.json"), type: "application/json" }
+      ],
+      "service-doc": [{ href: abs("/"), type: "text/html" }]
+    });
+  }
+  return entries;
+};
+var hasApiCatalog = (config) => linksetEntries(config).length > 0;
+var buildApiCatalog = (config) => {
+  const linkset = linksetEntries(config);
+  if (linkset.length === 0) {
+    return null;
+  }
+  return `${JSON.stringify({ linkset }, null, 2)}
+`;
+};
+
+// src/ai/link-headers.ts
+var buildHomeLinkHeader = (config, routePaths) => {
+  const deployBase = normalizeBasePath(config.deployment.base);
+  const links = [];
+  if (hasApiCatalog(config)) {
+    links.push(`<${deployBase}${API_CATALOG_PATH}>; rel="api-catalog"; type="application/linkset+json"`);
+  }
+  if (config.seo.agentReadability) {
+    links.push(`<${deployBase}/agent-readability.json>; rel="describedby"; type="application/json"`);
+  }
+  if (config.ai.llmsTxt.enabled) {
+    links.push(`<${deployBase}/llms.txt>; rel="describedby"; type="text/plain"`);
+  }
+  if (routePaths.includes("/")) {
+    links.push(`<${deployBase}/index.md>; rel="alternate"; type="text/markdown"`);
+  }
+  return links.length > 0 ? links.join(", ") : null;
+};
+
+// src/core/sources/watch.ts
+var BLUME_IGNORE_DIRS = [
+  ".blume",
+  ".blume-verify",
+  ".cache",
+  ".git",
+  ".next",
+  ".turbo",
+  ".vercel",
+  "dist",
+  "node_modules"
+];
+var baselineScanIgnore = () => BLUME_IGNORE_DIRS.map((dir) => `**/${dir}/**`);
+var BLUME_WATCH_IGNORE_DIRS = BLUME_IGNORE_DIRS;
+var excludeDirSegments = (patterns) => patterns.map((pattern) => /^(?<dir>[^*/]+)\/\*\*$/u.exec(pattern)?.groups?.dir).filter((dir) => dir !== undefined);
+var ignoringWatchListener = (onChange, ignoreDirs = BLUME_WATCH_IGNORE_DIRS) => {
+  const ignore = new Set(ignoreDirs);
+  return (_event, filename) => {
+    if (typeof filename === "string" && filename.split(/[/\\]/u).some((segment) => ignore.has(segment))) {
+      return;
+    }
+    onChange();
+  };
+};
+
+// src/deploy/redirects.ts
+var applyBaseToAstroRedirects = (redirects, basePath, deployBase) => {
+  const base = normalizeBasePath(deployBase);
+  return basePath || base ? redirects.map((redirect) => ({
+    ...redirect,
+    from: withBasePath(basePath, redirect.from),
+    to: withComposedBasePath(base, basePath, redirect.to)
+  })) : redirects;
+};
+var applyBaseToPlatformRedirects = (redirects, basePath, deployBase) => {
+  const base = normalizeBasePath(deployBase);
+  return basePath || base ? redirects.map((redirect) => ({
+    ...redirect,
+    from: withComposedBasePath(base, basePath, redirect.from),
+    to: withComposedBasePath(base, basePath, redirect.to)
+  })) : redirects;
+};
+var buildNetlifyRedirects = (redirects) => `${redirects.map((redirect) => `${redirect.from} ${redirect.to} ${redirect.status}`).join(`
+`)}
+`;
+var buildVercelConfig = (redirects) => `${JSON.stringify({
+  redirects: redirects.map((redirect) => ({
+    destination: redirect.to,
+    source: redirect.from,
+    statusCode: redirect.status
+  }))
+}, null, 2)}
+`;
+var buildRedirectManifest = (redirects) => `${JSON.stringify(redirects.map((redirect) => ({
+  from: redirect.from,
+  status: redirect.status,
+  to: redirect.to
+})), null, 2)}
+`;
+
 // src/search/providers.ts
 var SEARCH_PROVIDERS = {
   algolia: {
@@ -3341,30 +3521,94 @@ var GOOGLE_FONTS = {
 };
 var FONT_SLUGS = Object.keys(GOOGLE_FONTS);
 var isFontSlug = (value) => Object.hasOwn(GOOGLE_FONTS, value);
+var DEFAULT_REMOTE_WEIGHTS = [400, 500, 600, 700];
+var slugifyFontName = (name) => name.toLowerCase().replaceAll(/[^a-z0-9]+/gu, "-").replaceAll(/^-+|-+$/gu, "");
 var fontVar = (slug) => `--blume-ff-${slug}`;
 var SLOTS = ["display", "body", "mono"];
-var buildFontEntries = (fonts) => {
-  if (!fonts) {
-    return [];
-  }
-  const slugs = SLOTS.map((slot) => fonts[slot]).filter((slug) => typeof slug === "string" && isFontSlug(slug));
-  return [...new Set(slugs)].map((slug) => {
-    const def = GOOGLE_FONTS[slug];
+var slotCategory = (slot) => slot === "mono" ? "mono" : "sans";
+var resolveFontValue = (slot, value) => {
+  if (typeof value === "string") {
+    if (!isFontSlug(value)) {
+      return null;
+    }
+    const def = GOOGLE_FONTS[value];
     return {
-      cssVariable: fontVar(slug),
+      cssVariable: fontVar(value),
       fallbacks: FALLBACKS[def.category],
+      kind: "remote",
       name: def.family,
+      provider: "google",
       weights: def.weights
     };
-  });
+  }
+  const slug = slugifyFontName(value.name);
+  const fallbacks = FALLBACKS[value.fallback ?? slotCategory(slot)];
+  if ("variants" in value) {
+    return {
+      cssVariable: fontVar(slug),
+      fallbacks,
+      kind: "local",
+      name: value.name,
+      variants: value.variants
+    };
+  }
+  return {
+    cssVariable: fontVar(slug),
+    fallbacks,
+    kind: "remote",
+    name: value.name,
+    provider: value.provider ?? "google",
+    weights: value.weights ?? DEFAULT_REMOTE_WEIGHTS
+  };
+};
+var mergeFontEntries = (current, next) => {
+  if (current.kind === "remote" && next.kind === "remote" && current.provider === next.provider && current.name === next.name) {
+    return {
+      ...current,
+      weights: [...new Set([...current.weights, ...next.weights])]
+    };
+  }
+  if (current.kind === "local" && next.kind === "local" && current.name === next.name && JSON.stringify(current.variants) === JSON.stringify(next.variants)) {
+    return current;
+  }
+  throw new Error(`theme.fonts: "${next.name}" conflicts with "${current.name}" — both resolve to the CSS variable "${current.cssVariable}" with different definitions. Rename one family or align their definitions.`);
+};
+var buildFontEntries = (fonts) => {
+  if (!fonts) {
+    return [];
+  }
+  const entries = new Map;
+  for (const slot of SLOTS) {
+    const value = fonts[slot];
+    if (value === undefined) {
+      continue;
+    }
+    const entry = resolveFontValue(slot, value);
+    if (!entry) {
+      continue;
+    }
+    const current = entries.get(entry.cssVariable);
+    entries.set(entry.cssVariable, current ? mergeFontEntries(current, entry) : entry);
+  }
+  return [...entries.values()];
+};
+var slotSlug = (value) => {
+  if (typeof value === "string") {
+    return isFontSlug(value) ? value : null;
+  }
+  return slugifyFontName(value.name);
 };
 var buildFontsCss = (fonts) => {
   if (!fonts) {
     return "";
   }
   const lines = SLOTS.flatMap((slot) => {
-    const slug = fonts[slot];
-    return slug && isFontSlug(slug) ? [`  --blume-font-${slot}-src: var(${fontVar(slug)});`] : [];
+    const value = fonts[slot];
+    if (value === undefined) {
+      return [];
+    }
+    const slug = slotSlug(value);
+    return slug ? [`  --blume-font-${slot}-src: var(${fontVar(slug)});`] : [];
   });
   return lines.length > 0 ? `/* Generated by Blume from theme.fonts. */
 :root {
@@ -3533,6 +3777,8 @@ const blumeConfig = await loadBlumeConfig(resolve(dirname(fileURLToPath(import.m
     userIntegrationSpread: ", ...(blumeConfig?.integrations ?? [])"
   };
 };
+var renderImageOption = (config) => config.image.domains.length > 0 || config.image.remotePatterns.length > 0 ? `
+  image: ${JSON.stringify(config.image)},` : "";
 var astroConfigTemplate = (options) => {
   const { context, config, needsReact, pages, dataPath, themePath } = options;
   const {
@@ -3568,6 +3814,7 @@ var astroConfigTemplate = (options) => {
   site: ${JSON.stringify(deployment.site)},` : "";
   const baseOption = deployment.base ? `
   base: ${JSON.stringify(deployment.base)},` : "";
+  const imageOption = renderImageOption(config);
   const i18nOption = config.i18n ? `
   i18n: ${JSON.stringify({
     defaultLocale: config.i18n.defaultLocale,
@@ -3584,7 +3831,13 @@ var astroConfigTemplate = (options) => {
   ])))},` : "";
   const fontEntries = buildFontEntries(config.theme.fonts);
   const fontsOption = fontEntries.length ? `
-  fonts: [${fontEntries.map((font) => `{ provider: fontProviders.google(), name: ${JSON.stringify(font.name)}, cssVariable: ${JSON.stringify(font.cssVariable)}, weights: ${JSON.stringify(font.weights)}, fallbacks: ${JSON.stringify(font.fallbacks)} }`).join(", ")}],` : "";
+  fonts: [${fontEntries.map((font) => font.kind === "local" ? `{ provider: fontProviders.local(), name: ${JSON.stringify(font.name)}, cssVariable: ${JSON.stringify(font.cssVariable)}, fallbacks: ${JSON.stringify(font.fallbacks)}, options: { variants: ${JSON.stringify(font.variants.map((variant) => ({
+    ...variant.weight === undefined ? {} : { weight: variant.weight },
+    ...variant.style === undefined ? {} : { style: variant.style },
+    src: [
+      isAbsolute(variant.src) ? variant.src : join8(context.root, variant.src)
+    ]
+  })))} } }` : `{ provider: fontProviders.${font.provider}(), name: ${JSON.stringify(font.name)}, cssVariable: ${JSON.stringify(font.cssVariable)}, weights: ${JSON.stringify(font.weights)}, fallbacks: ${JSON.stringify(font.fallbacks)} }`).join(", ")}],` : "";
   const defineConfigImport = astroConfigImportLine({
     hasFonts: fontEntries.length > 0,
     hasSession: sessionOption.length > 0
@@ -3622,7 +3875,12 @@ var astroConfigTemplate = (options) => {
   if (needsSvelte) {
     integrations.push("svelte()");
   }
-  integrations.push(`blumeIntegration(${JSON.stringify({ base: deployment.base, contentRoutes, pages })})`);
+  integrations.push(`blumeIntegration(${JSON.stringify({
+    base: deployment.base,
+    contentRoutes,
+    homeLinkHeader: buildHomeLinkHeader(config, contentRoutes) ?? undefined,
+    pages
+  })})`);
   const watchOption = devWatchOption(context.outDir, options.contentWatchesRuntimeDir);
   const {
     configSourceMarker,
@@ -3641,7 +3899,7 @@ ${userConfigSetup}export default defineConfig({
   srcDir: ${JSON.stringify(`${context.outDir}/src`)},
   outDir: ${JSON.stringify(astroOutDir(context))},
   publicDir: ${JSON.stringify(`${context.root}/public`)},
-  output: ${JSON.stringify(deployment.output)},${adapterOption}${sessionOption}${siteOption}${baseOption}${redirectsOption}${i18nOption}${fontsOption}
+  output: ${JSON.stringify(deployment.output)},${adapterOption}${sessionOption}${siteOption}${baseOption}${imageOption}${redirectsOption}${i18nOption}${fontsOption}
   integrations: [${integrations.join(", ")}${userIntegrationSpread}],
   markdown: {
     processor: blumeMarkdownProcessor(${JSON.stringify({
@@ -3832,17 +4090,17 @@ const ground = createAskContext(askData);
   const onError = `      onError({ error }) {
         console.error("Ask AI provider error:", error);
       },`;
-  const stream = grounded ? `    const system =
+  const stream = grounded ? `    const instructions =
       (await ground(messages, body.page)) ??
       "You are a helpful documentation assistant. Answer using the project's documentation.";
     const result = streamText({
       model: ${modelExpr},
-      system,
+      instructions,
       messages,
 ${onError}
     });` : `    const result = streamText({
       model: ${modelExpr},
-      system:
+      instructions:
         "You are a helpful documentation assistant. Answer using the project's documentation.",
       messages,
 ${onError}
@@ -3903,10 +4161,10 @@ var searchClientImport = (module) => `import { createSearch as create } from "bl
 `;
 var SEARCH_BASE_IMPORT = `import { joinBase } from "blume/components/islands/base-path.ts";
 `;
-var staticSearchClient = (module) => `${SEARCH_CLIENT_HEADER}${searchClientImport(module)}${SEARCH_BASE_IMPORT}
+var staticSearchClient = (module, locale) => `${SEARCH_CLIENT_HEADER}${searchClientImport(module)}${SEARCH_BASE_IMPORT}
 const indexUrl = joinBase(import.meta.env.BASE_URL, "blume-search.json");
 
-export const createSearch = () => create({ indexUrl });
+export const createSearch = () => create({ indexUrl${locale ? `, locale: ${JSON.stringify(locale)}` : ""} });
 `;
 var hostedSearchClient = (module, options) => `${SEARCH_CLIENT_HEADER}${searchClientImport(module)}
 export const createSearch = () => create(${JSON.stringify(options)});
@@ -3936,7 +4194,7 @@ var hostedSearchOptions = (search) => {
 var searchClientTemplate = (config) => {
   const { search } = config;
   if (search.provider === "orama" || search.provider === "flexsearch") {
-    return staticSearchClient(search.provider);
+    return staticSearchClient(search.provider, search.provider === "orama" ? config.i18n?.defaultLocale : undefined);
   }
   const hosted = hostedSearchOptions(search);
   if (hosted) {
@@ -4016,6 +4274,86 @@ export function GET({ props }: { props: { route: string } }) {
   });
 }
 `;
+var contentAssetsEndpointTemplate = (stagedAssetsDir) => `// Generated by Blume. Do not edit.
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import type { APIRoute } from "astro";
+import assets from "../../generated/content-assets.json";
+
+export const prerender = true;
+
+const files = assets as Record<string, string>;
+const STAGED_DIR = ${JSON.stringify(stagedAssetsDir)};
+
+const TYPES: Record<string, string> = {
+  ".apng": "image/apng",
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".tiff": "image/tiff",
+  ".webp": "image/webp",
+};
+
+const contentType = (path: string): string =>
+  TYPES[path.slice(path.lastIndexOf(".")).toLowerCase()] ??
+  "application/octet-stream";
+
+const stagedParams = async (): Promise<string[]> => {
+  if (!existsSync(STAGED_DIR)) {
+    return [];
+  }
+  const entries = await readdir(STAGED_DIR, {
+    recursive: true,
+    withFileTypes: true,
+  });
+  return entries
+    .filter((entry) => entry.isFile())
+    .map((entry) =>
+      relative(STAGED_DIR, join(entry.parentPath, entry.name)).replaceAll(
+        "\\\\",
+        "/"
+      )
+    );
+};
+
+export async function getStaticPaths() {
+  const params = [
+    ...Object.keys(files).map((key) => "content/" + key),
+    ...(await stagedParams()),
+  ];
+  return params.map((asset) => ({ params: { asset } }));
+}
+
+const resolveAsset = (asset: string): string | null => {
+  if (asset.startsWith("content/")) {
+    return files[asset.slice("content/".length)] ?? null;
+  }
+  const abs = resolve(STAGED_DIR, asset);
+  // Traversal guard: the dev server renders on demand, so the param is
+  // attacker-controlled there — never step outside the staged directory.
+  if (!abs.startsWith(STAGED_DIR + "/")) {
+    return null;
+  }
+  return existsSync(abs) ? abs : null;
+};
+
+export const GET: APIRoute = async ({ params }) => {
+  const path = resolveAsset(String(params.asset ?? ""));
+  if (!path) {
+    return new Response(null, { status: 404 });
+  }
+  const body = await readFile(path);
+  return new Response(new Uint8Array(body), {
+    headers: { "Content-Type": contentType(path) },
+  });
+};
+`;
 var mcpPageFile = (route) => `${trimChar(route, "/")}.ts`;
 var mcpEndpointTemplate = (route) => {
   const clean = trimChar(route, "/");
@@ -4062,8 +4400,9 @@ export function GET({ props }: { props: { section: string } }) {
   });
 }
 `;
-var ogEndpointTemplate = (customRoutes = []) => `// Generated by Blume. Do not edit.
+var ogEndpointTemplate = (customRoutes = [], og = {}) => `// Generated by Blume. Do not edit.
 import { renderOgImage } from "blume/og";
+import type { OgFont, OgFontFamilies } from "blume/og";
 import data from "blume:data";
 
 export const prerender = true;
@@ -4073,6 +4412,13 @@ export const prerender = true;
 // (ts(7034)) under a strict tsconfig.
 const customRoutes: { slug: string; title: string }[] = ${JSON.stringify(customRoutes)};
 
+// Card fonts, resolved at generation time (explicit seo.og.fonts, or derived
+// from theme.fonts). Local entries carry absolute build-machine paths, which
+// is why they are baked into this build-only endpoint instead of the runtime
+// data that pages serialize into HTML.
+const fonts: OgFont[] = ${JSON.stringify(og.fonts ?? [])};
+const families: OgFontFamilies | undefined = ${og.families ? JSON.stringify(og.families) : "undefined"};
+
 export function getStaticPaths() {
   const seen = new Set<string>();
   const paths: { params: { slug: string }; props: { title: string } }[] = [];
@@ -4093,32 +4439,23 @@ export function getStaticPaths() {
   return paths;
 }
 
-// Footer branding shared by every card, derived once from the resolved config.
-// The repo slug reuses the header link URL; the host comes from the site URL.
+// Footer branding shared by every card. The repo slug reuses the header link
+// URL; the site text (host plus deployment base) is resolved at generate time.
 const repoSlug = data.config.repoUrl
   ? data.config.repoUrl.split("github.com/")[1]
   : undefined;
-const siteHost = (() => {
-  if (!data.config.site) {
-    return undefined;
-  }
-  try {
-    return new URL(data.config.site).host;
-  } catch {
-    return undefined;
-  }
-})();
 
 export async function GET({ props }: { props: { title: string } }) {
   const png = await renderOgImage({
     accent: data.config.og.palette?.accent ?? data.config.theme.accent.light,
     brand: data.config.title,
-    description: data.config.description,
-    fonts: data.config.og.fonts,
+    description: data.config.og.description,
+    families,
+    fonts,
     logo: data.config.og.logo,
     palette: data.config.og.palette,
     repo: repoSlug,
-    site: siteHost,
+    site: data.config.og.site,
     title: props.title,
   });
   return new Response(new Uint8Array(png), {
@@ -5274,6 +5611,7 @@ var MODULES = [
   structuredDataChecks,
   urlChecks,
   networkChecks,
+  dnsAidChecks,
   externalChecks
 ];
 
@@ -7436,7 +7774,7 @@ var uiStringsObject = z.object({
     generating: z.string().default("Generating…"),
     openInChat: z.string().default("Open in chat"),
     scrollToTop: z.string().default("Scroll to top")
-  }).default({}),
+  }).prefault({}),
   ask: z.object({
     ai: z.string().default("AI"),
     clear: z.string().default("Clear conversation"),
@@ -7450,28 +7788,28 @@ var uiStringsObject = z.object({
     tip: z.string().default("Tip: You can open and close chat with"),
     title: z.string().default("Ask AI"),
     you: z.string().default("You")
-  }).default({}),
+  }).prefault({}),
   banner: z.object({
     dismiss: z.string().default("Dismiss announcement")
-  }).default({}),
+  }).prefault({}),
   changelog: z.object({
     description: z.string().default("Product updates, new features, and fixes from every release."),
     showReleases: z.string().default("Show {version} releases"),
     title: z.string().default("Changelog")
-  }).default({}),
+  }).prefault({}),
   content: z.object({
     diagramError: z.string().default("Could not render this diagram.")
-  }).default({}),
+  }).prefault({}),
   feedback: z.object({
     no: z.string().default("No"),
     question: z.string().default("Was this page helpful?"),
     thanks: z.string().default("Thanks for your feedback!"),
     yes: z.string().default("Yes")
-  }).default({}),
+  }).prefault({}),
   languageSwitcher: z.object({
     label: z.string().default("Language"),
     untranslated: z.string().default("Not translated")
-  }).default({}),
+  }).prefault({}),
   nav: z.object({
     back: z.string().default("Back"),
     breadcrumb: z.string().default("Breadcrumb"),
@@ -7484,19 +7822,19 @@ var uiStringsObject = z.object({
     sections: z.string().default("Sections"),
     toggleNavigation: z.string().default("Toggle navigation"),
     toggleTheme: z.string().default("Toggle color theme")
-  }).default({}),
+  }).prefault({}),
   notFound: z.object({
     description: z.string().default("We couldn't find the page you're looking for."),
     home: z.string().default("Back to home"),
     title: z.string().default("Page not found")
-  }).default({}),
+  }).prefault({}),
   page: z.object({
     lastUpdated: z.string().default("Last updated on"),
     next: z.string().default("Next"),
     pagination: z.string().default("Pagination"),
     previous: z.string().default("Previous"),
     skipToContent: z.string().default("Skip to content")
-  }).default({}),
+  }).prefault({}),
   search: z.object({
     all: z.string().default("All"),
     allLanguages: z.string().default("All languages"),
@@ -7513,14 +7851,13 @@ var uiStringsObject = z.object({
     popular: z.string().default("Popular"),
     preview: z.string().default("preview"),
     results: z.string().default("Results")
-  }).default({}),
+  }).prefault({}),
   toc: z.object({
     title: z.string().default("On this page")
-  }).default({})
+  }).prefault({})
 });
-var uiStringsSchema = uiStringsObject.default({});
-var EN_UI_INPUT = Object.fromEntries(Object.keys(uiStringsObject.shape).map((group) => [group, {}]));
-var EN_UI = uiStringsObject.parse(EN_UI_INPUT);
+var uiStringsSchema = uiStringsObject.prefault({});
+var EN_UI = uiStringsObject.parse({});
 var uiStringsOverrideSchema = z.record(z.string(), z.record(z.string(), z.string()));
 var uiLocaleOverridesSchema = z.record(z.string(), uiStringsOverrideSchema);
 var mergeUI = (base, override) => {
@@ -7570,7 +7907,7 @@ var sidebarMetaSchema = z2.strictObject({
 });
 var xHandleSchema = z2.string().transform(normalizeXHandle).optional();
 var seoMetaSchema = z2.strictObject({
-  canonical: z2.string().url().optional(),
+  canonical: z2.url().optional(),
   description: z2.string().optional(),
   image: z2.string().optional(),
   noindex: z2.boolean().default(false),
@@ -7600,7 +7937,7 @@ var authorSchema = z2.union([
   }).catchall(z2.unknown())
 ]);
 var pageMetaBaseSchema = z2.strictObject({
-  ai: aiMetaSchema.default({}),
+  ai: aiMetaSchema.prefault({}),
   authors: z2.union([authorSchema, z2.array(authorSchema)]).optional(),
   changelog: changelogMetaSchema.optional(),
   date: dateSchema.optional(),
@@ -7611,9 +7948,9 @@ var pageMetaBaseSchema = z2.strictObject({
   icon: iconName.optional(),
   lastModified: dateSchema.optional(),
   noindex: z2.boolean().default(false),
-  search: searchMetaSchema.default({}),
-  seo: seoMetaSchema.default({}),
-  sidebar: sidebarMetaSchema.default({}),
+  search: searchMetaSchema.prefault({}),
+  seo: seoMetaSchema.prefault({}),
+  sidebar: sidebarMetaSchema.prefault({}),
   slug: z2.string().optional(),
   title: z2.string().optional(),
   type: z2.string().optional()
@@ -7773,11 +8110,31 @@ var sidebarItemSchema = z2.lazy(() => z2.union([
     root: z2.string().optional()
   })
 ]));
-var fontSlug = z2.string().superRefine((value, ctx) => {
-  if (!isFontSlug(value)) {
+var fontFallbackSchema = z2.enum(["sans", "serif", "mono"]);
+var remoteFontSchema = z2.strictObject({
+  fallback: fontFallbackSchema.optional(),
+  name: z2.string().min(1),
+  provider: z2.enum(["google", "fontsource", "bunny", "fontshare"]).default("google"),
+  weights: z2.array(z2.union([z2.number().int().positive(), z2.string().regex(/^\d+\.\.\d+$/u)])).nonempty().optional()
+});
+var localFontVariantSchema = z2.strictObject({
+  src: z2.string().min(1),
+  style: z2.enum(["normal", "italic", "oblique"]).optional(),
+  weight: z2.union([
+    z2.number().int().positive(),
+    z2.string().regex(/^\d+(?:\.\.\d+)?$/u)
+  ]).optional()
+});
+var localFontSchema = z2.strictObject({
+  fallback: fontFallbackSchema.optional(),
+  name: z2.string().min(1),
+  variants: z2.array(localFontVariantSchema).nonempty()
+});
+var fontValueSchema = z2.union([z2.string(), remoteFontSchema, localFontSchema]).superRefine((value, ctx) => {
+  if (typeof value === "string" && !isFontSlug(value)) {
     ctx.addIssue({
       code: z2.ZodIssueCode.custom,
-      message: `Unknown font "${value}". Supported fonts: ${FONT_SLUGS.join(", ")}.`
+      message: `Unknown font "${value}". Supported fonts: ${FONT_SLUGS.join(", ")}. For any other family, use the object form: { name: "..." } (remote provider) or { name: "...", variants: [...] } (local files).`
     });
   }
 });
@@ -7797,10 +8154,10 @@ var themeConfigSchema = z2.strictObject({
   background: perModeValueSchema,
   backgroundImage: perModeValueSchema,
   fonts: z2.strictObject({
-    body: fontSlug.default("inter"),
-    display: fontSlug.default("inter-tight"),
-    mono: fontSlug.default("ibm-plex-mono")
-  }).default({}),
+    body: fontValueSchema.default("inter"),
+    display: fontValueSchema.default("inter-tight"),
+    mono: fontValueSchema.default("ibm-plex-mono")
+  }).prefault({}),
   layout: z2.enum(["sidebar"]).default("sidebar"),
   mode: z2.enum(["system", "light", "dark"]).default("system"),
   radius: z2.enum(["none", "sm", "md", "lg"]).default("md")
@@ -7850,7 +8207,7 @@ var searchConfigSchema = z2.strictObject({
   algolia: algoliaSearchSchema.optional(),
   indexing: z2.strictObject({
     includeHiddenPages: z2.boolean().default(false)
-  }).default({}),
+  }).prefault({}),
   mixedbread: mixedbreadSearchSchema.optional(),
   oramaCloud: oramaCloudSearchSchema.optional(),
   popular: z2.array(searchPopularLinkSchema).default([]),
@@ -7873,6 +8230,22 @@ var askAiProviders = [
   "inkeep",
   "openai-compatible"
 ];
+var PRIVATE_JWK_PARAMS = ["d", "p", "q", "dp", "dq", "qi", "oth", "k"];
+var publicJwkSchema = z2.record(z2.string(), z2.unknown()).superRefine((jwk, ctx) => {
+  if (typeof jwk.kty !== "string" || jwk.kty.length === 0) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: 'A JWK must declare its key type ("kty").'
+    });
+  }
+  const leaked = PRIVATE_JWK_PARAMS.filter((param) => (param in jwk));
+  if (leaked.length > 0) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: `The JWK contains private key material ("${leaked.join('", "')}") — the signatures directory is public, so list only public keys and keep the private key where the signing agent runs.`
+    });
+  }
+});
 var mcpConfigSchema = z2.strictObject({
   enabled: z2.boolean().default(false),
   instructions: z2.string().optional(),
@@ -7895,7 +8268,7 @@ var askEndpointSchema = z2.string().trim().min(1).refine((value) => {
 var aiConfigSchema = z2.strictObject({
   ask: z2.strictObject({
     apiKeyEnv: z2.string().optional(),
-    baseUrl: z2.string().url().optional(),
+    baseUrl: z2.url().optional(),
     enabled: z2.boolean().default(false),
     endpoint: askEndpointSchema.optional(),
     model: z2.string().default("openai/gpt-5.5"),
@@ -7923,7 +8296,12 @@ var aiConfigSchema = z2.strictObject({
   markdownComponents: z2.record(z2.string(), z2.custom((value) => typeof value === "function", {
     message: "Expected a serializer function."
   })).default({}),
-  mcp: mcpConfigSchema.default({})
+  mcp: mcpConfigSchema.prefault({}),
+  skills: z2.string().min(1).optional(),
+  webBotAuth: z2.strictObject({
+    keys: z2.array(publicJwkSchema).default([])
+  }).prefault({}),
+  webmcp: z2.boolean().default(true)
 });
 var featuredLinkSchema = z2.strictObject({
   href: z2.string(),
@@ -7940,7 +8318,7 @@ var navigationConfigSchema = z2.strictObject({
       display: sidebarDisplaySchema.default("flat"),
       items: z2.array(sidebarItemSchema).optional()
     })
-  ]).default({}).transform((value) => Array.isArray(value) ? { display: "flat", items: value } : value),
+  ]).prefault({}).transform((value) => Array.isArray(value) ? { display: "flat", items: value } : value),
   tabs: z2.array(navTabSchema).default([])
 });
 var exportConfigSchema = z2.union([
@@ -7999,13 +8377,23 @@ var deploymentConfigSchema = z2.strictObject({
   adapter: z2.enum(["vercel", "node", "netlify", "cloudflare"]).nullable().default(null),
   base: z2.string().optional(),
   output: z2.enum(["static", "server"]).default("static"),
-  site: z2.string().url().optional()
+  site: z2.url().optional()
 });
 var redirectSchema = z2.strictObject({
   from: z2.string(),
   status: z2.union([z2.literal(301), z2.literal(302), z2.literal(307), z2.literal(308)]).default(301),
   to: z2.string()
 });
+var imageRemotePatternSchema = z2.strictObject({
+  hostname: z2.string().optional(),
+  pathname: z2.string().optional(),
+  port: z2.string().optional(),
+  protocol: z2.string().optional()
+});
+var imageConfigSchema = z2.strictObject({
+  domains: z2.array(z2.string()).default([]),
+  remotePatterns: z2.array(imageRemotePatternSchema).default([])
+});
 var xConfigSchema = z2.strictObject({
   creator: xHandleSchema,
   handle: xHandleSchema
@@ -8030,13 +8418,21 @@ var ogFontSchema = z2.union([
     name: z2.string(),
     style: z2.union([ogFontStyleSchema, z2.array(ogFontStyleSchema)]).optional(),
     weight: ogFontWeightSchema.optional()
+  }),
+  z2.strictObject({
+    name: z2.string(),
+    src: z2.string().min(1),
+    style: ogFontStyleSchema.optional(),
+    weight: z2.number().int().positive().optional()
   })
 ]);
 var ogConfigSchema = z2.strictObject({
+  description: z2.union([z2.string(), z2.literal(false)]).optional(),
   enabled: z2.boolean().optional(),
   fonts: z2.array(ogFontSchema).optional(),
-  logo: z2.string().optional(),
+  logo: z2.union([z2.string(), z2.literal(false)]).optional(),
   palette: ogPaletteSchema.optional(),
+  site: z2.union([z2.string(), z2.literal(false)]).optional(),
   titles: z2.record(z2.string(), z2.string()).optional()
 });
 var rssConfigSchema = z2.strictObject({
@@ -8060,10 +8456,10 @@ var contentSignalsSchema = z2.union([z2.boolean(), contentSignalsObjectSchema]).
 });
 var seoConfigSchema = z2.strictObject({
   agentReadability: z2.boolean().default(true),
-  contentSignals: contentSignalsSchema.default(true),
+  contentSignals: contentSignalsSchema.prefault(true),
   og: ogConfigSchema.default({}),
   robots: z2.boolean().default(true),
-  rss: rssConfigSchema.default({}),
+  rss: rssConfigSchema.prefault({}),
   sitemap: z2.boolean().default(true),
   structuredData: z2.boolean().default(true),
   x: xConfigSchema.default({})
@@ -8093,7 +8489,7 @@ var codeBlockThemeSchema = z2.strictObject({
   light: codeThemeSchema.default("github-light")
 });
 var codeBlocksConfigSchema = z2.strictObject({
-  theme: codeBlockThemeSchema.default({})
+  theme: codeBlockThemeSchema.prefault({})
 });
 var examplesConfigSchema = z2.union([
   z2.string(),
@@ -8124,8 +8520,8 @@ var codeConfigSchema = z2.strictObject({
   wrap: z2.boolean().default(false)
 });
 var markdownConfigSchema = z2.strictObject({
-  code: codeConfigSchema.default({}),
-  codeBlocks: codeBlocksConfigSchema.default({}),
+  code: codeConfigSchema.prefault({}),
+  codeBlocks: codeBlocksConfigSchema.prefault({}),
   headingAnchors: z2.boolean().default(true),
   imageZoom: z2.boolean().default(true)
 });
@@ -8194,32 +8590,33 @@ var tocConfigSchema = z2.union([
   message: "toc.minHeadingLevel must be less than or equal to toc.maxHeadingLevel."
 });
 var blumeConfigSchema = z2.strictObject({
-  ai: aiConfigSchema.default({}),
+  ai: aiConfigSchema.prefault({}),
   analytics: analyticsConfigSchema.optional(),
-  asyncapi: asyncapiConfigSchema.default({}),
+  asyncapi: asyncapiConfigSchema.prefault({}),
   banner: bannerConfigSchema.optional(),
   basePath: z2.string().optional().transform((value) => normalizeBasePath(value)),
-  content: contentConfigSchema.default({}),
+  content: contentConfigSchema.prefault({}),
   dateFormat: dateFormatConfigSchema.default({ dateStyle: "long" }),
-  deployment: deploymentConfigSchema.default({}),
+  deployment: deploymentConfigSchema.prefault({}),
   description: z2.string().optional(),
-  examples: examplesConfigSchema.default("examples"),
-  export: exportConfigSchema.default(false),
+  examples: examplesConfigSchema.prefault("examples"),
+  export: exportConfigSchema.prefault(false),
   feedback: z2.boolean().default(true),
-  frontmatter: frontmatterConfigSchema.default({}),
+  frontmatter: frontmatterConfigSchema.prefault({}),
   github: githubConfigSchema.optional(),
   i18n: i18nConfigSchema.optional(),
+  image: imageConfigSchema.prefault({}),
   integrations: z2.array(z2.custom()).default([]),
   lastModified: lastModifiedConfigSchema.default(false),
   logo: logoConfigSchema.optional(),
-  markdown: markdownConfigSchema.default({}),
-  navigation: navigationConfigSchema.default({}),
-  openapi: openapiConfigSchema.default({}),
-  react: reactConfigSchema.default({}),
+  markdown: markdownConfigSchema.prefault({}),
+  navigation: navigationConfigSchema.prefault({}),
+  openapi: openapiConfigSchema.prefault({}),
+  react: reactConfigSchema.prefault({}),
   redirects: z2.array(redirectSchema).default([]),
-  search: searchConfigSchema.default({}),
-  seo: seoConfigSchema.default({}),
-  theme: themeConfigSchema.default({}),
+  search: searchConfigSchema.prefault({}),
+  seo: seoConfigSchema.prefault({}),
+  theme: themeConfigSchema.prefault({}),
   title: z2.string().default("Documentation"),
   toc: tocConfigSchema
 });
@@ -8241,6 +8638,7 @@ var loadConfig = async (root, options = {}) => {
       });
     }
   }
+  const themeFontsConfigured = Boolean(raw && typeof raw === "object" && raw.theme?.fonts !== undefined);
   const parsed = blumeConfigSchema.safeParse(raw ?? {});
   if (!parsed.success) {
     const source = configFile && existsSync6(configFile) ? readFileSync3(configFile, "utf-8") : undefined;
@@ -8275,7 +8673,8 @@ ${moreIssues}`
       seo: { ...config.seo, og: { ...config.seo.og, enabled: ogEnabled } }
     },
     configFile,
-    diagnostics: []
+    diagnostics: [],
+    themeFontsConfigured
   };
 };
 
@@ -11396,7 +11795,8 @@ var scanProject = async (root, options = {}) => {
     graph,
     manifest,
     mode,
-    sources
+    sources,
+    themeFontsConfigured: configResult.themeFontsConfigured
   };
 };
 
@@ -11580,11 +11980,11 @@ var auditCommand = defineCommand2({
 });
 
 // src/cli/commands/build.ts
-import { existsSync as existsSync16 } from "node:fs";
-import { readdir, stat as stat2, writeFile as writeFile8 } from "node:fs/promises";
+import { existsSync as existsSync18 } from "node:fs";
+import { mkdir as mkdir7, readdir as readdir2, readFile as readFile17, stat as stat3, writeFile as writeFile8 } from "node:fs/promises";
 import { build } from "astro";
 import { defineCommand as defineCommand3 } from "citty";
-import { join as join28 } from "pathe";
+import { dirname as dirname12, join as join30, resolve as resolve10 } from "pathe";
 
 // src/deploy/xml.ts
 var escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
@@ -11688,6 +12088,19 @@ var askApiUrl = (endpoint, site, abs) => {
   }
   return site && endpoint.startsWith("/") ? `${site.replace(/\/+$/u, "")}${endpoint}` : endpoint;
 };
+var wellKnownArtifacts = (config, abs) => {
+  const artifacts = {};
+  if (config.ai.webBotAuth.keys.length > 0) {
+    artifacts.httpMessageSignaturesDirectory = abs("/.well-known/http-message-signatures-directory");
+  }
+  if (hasApiCatalog(config)) {
+    artifacts.apiCatalog = abs("/.well-known/api-catalog");
+  }
+  if (config.ai.skills) {
+    artifacts.agentSkills = abs("/.well-known/agent-skills/index.json");
+  }
+  return artifacts;
+};
 var buildAgentReadability = (project) => {
   const { config } = project;
   if (!config.seo.agentReadability) {
@@ -11699,9 +12112,10 @@ var buildAgentReadability = (project) => {
     const based = withBasePath(deployBase, path);
     return site ? `${site.replace(/\/+$/u, "")}${based}` : based;
   };
+  const negotiates = config.deployment.output === "server" && config.deployment.adapter === "vercel";
   const artifacts = {
     markdown: {
-      contentNegotiation: "text/markdown",
+      ...negotiates ? { contentNegotiation: "text/markdown" } : {},
       pattern: abs("/{route}.md")
     }
   };
@@ -11718,6 +12132,7 @@ var buildAgentReadability = (project) => {
   if (config.ai.ask?.enabled) {
     artifacts.askApi = askApiUrl(config.ai.ask.endpoint, site, abs);
   }
+  Object.assign(artifacts, wellKnownArtifacts(config, abs));
   if (site && config.seo.sitemap) {
     artifacts.sitemap = abs("/sitemap.xml");
   }
@@ -11743,8 +12158,113 @@ var buildAgentReadability = (project) => {
   return manifest;
 };
 
+// src/core/content-assets.ts
+import { existsSync as existsSync9 } from "node:fs";
+import { readFile as readFile8 } from "node:fs/promises";
+import { dirname as dirname7, extname as extname5, relative as relative11, resolve as resolve5 } from "pathe";
+var CONTENT_ASSETS_PREFIX = "/blume-assets/content";
+var IMAGE_EXTENSIONS = new Set([
+  ".apng",
+  ".avif",
+  ".bmp",
+  ".gif",
+  ".ico",
+  ".jpeg",
+  ".jpg",
+  ".png",
+  ".svg",
+  ".tiff",
+  ".webp"
+]);
+var isRelativeTarget = (target) => !(target.startsWith("/") || target.startsWith("#")) && !URL.canParse(target);
+var contentAssetParam = (projectRoot, absPath) => {
+  const rel = relative11(projectRoot, absPath);
+  if (rel.startsWith("..")) {
+    return `_/${hashText(absPath)}${extname5(absPath)}`;
+  }
+  return rel;
+};
+var resolveRelativeImage = (sourceDir, target) => {
+  if (!isRelativeTarget(target)) {
+    return null;
+  }
+  let decoded = target;
+  try {
+    decoded = decodeURI(target);
+  } catch {}
+  if (!IMAGE_EXTENSIONS.has(extname5(decoded).toLowerCase())) {
+    return null;
+  }
+  const abs = resolve5(sourceDir, decoded);
+  return existsSync9(abs) ? abs : null;
+};
+var encodedParam = (param) => param.split("/").map(encodeURIComponent).join("/");
+var rewriteLine = (line, toUrl2) => {
+  const masked = line.replaceAll(INLINE_CODE, (span) => " ".repeat(span.length));
+  let out = "";
+  let cursor = 0;
+  for (const match of masked.matchAll(MD_IMAGE)) {
+    const target = match.groups?.target ?? "";
+    const url = toUrl2(target);
+    if (url === null) {
+      continue;
+    }
+    const offset = (match.index ?? 0) + targetOffsetIn(match[0], target, match.groups?.title);
+    out += line.slice(cursor, offset) + url;
+    cursor = offset + target.length;
+  }
+  return out + line.slice(cursor);
+};
+var rewriteRelativeImages = (options) => {
+  const { source, sourcePath, projectRoot, deployBase, register } = options;
+  const sourceDir = dirname7(sourcePath);
+  const prefix = `${normalizeBasePath(deployBase)}${CONTENT_ASSETS_PREFIX}`;
+  const toUrl2 = (target) => {
+    const abs = resolveRelativeImage(sourceDir, target);
+    if (abs === null) {
+      return null;
+    }
+    const param = contentAssetParam(projectRoot, abs);
+    register?.(param, abs);
+    return `${prefix}/${encodedParam(param)}`;
+  };
+  let fence = null;
+  const lines = source.split(`
+`).map((line) => {
+    const next = nextFenceState(line, fence);
+    const inFence = fence !== null || next !== null;
+    fence = next;
+    return inFence ? line : rewriteLine(line, toUrl2);
+  });
+  return lines.join(`
+`);
+};
+var collectContentAssets = async (project) => {
+  const files = {};
+  await Promise.all(project.manifest.routes.map(async (route) => {
+    if (!route.sourcePath) {
+      return;
+    }
+    let source;
+    try {
+      source = await readFile8(route.sourcePath, "utf-8");
+    } catch {
+      return;
+    }
+    rewriteRelativeImages({
+      projectRoot: project.context.root,
+      register: (param, abs) => {
+        files[param] = abs;
+      },
+      source,
+      sourcePath: route.sourcePath
+    });
+  }));
+  return files;
+};
+
 // src/core/sources/read.ts
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 var readEntryText = async (ctx, page) => {
   if (page.body) {
     return page.body.text;
@@ -11755,7 +12275,7 @@ var readEntryText = async (ctx, page) => {
     return await source.read(page.source.ref);
   }
   if (page.sourcePath) {
-    return await readFile8(page.sourcePath, "utf-8");
+    return await readFile9(page.sourcePath, "utf-8");
   }
   return "";
 };
@@ -12154,7 +12674,15 @@ var buildFull = async (project) => {
     ...config.ai.markdownComponents
   };
   const sections = await Promise.all(pages.map(async (page) => {
-    const raw = await readEntryText(project, page);
+    let raw = await readEntryText(project, page);
+    if (page.sourcePath) {
+      raw = rewriteRelativeImages({
+        deployBase: config.deployment.base,
+        projectRoot: project.context.root,
+        source: raw,
+        sourcePath: page.sourcePath
+      });
+    }
     const parsed = frontmatter_default(raw);
     const body = downlevelComponents(applyAgentVisibility(parsed.content), components, parsed.data).trim();
     const url = pageUrl(page.route, config.deployment.site, normalizeBasePath(config.deployment.base));
@@ -12179,14 +12707,200 @@ var buildLlmsFiles = async (project) => ({
   index: buildIndex(project)
 });
 
-// src/core/gitignore.ts
-import { existsSync as existsSync9 } from "node:fs";
-import { readFile as readFile9, writeFile as writeFile6 } from "node:fs/promises";
+// src/ai/skills.ts
+import { createHash as createHash2 } from "node:crypto";
+import { readdir, readFile as readFile10, stat as stat2 } from "node:fs/promises";
 import { join as join18 } from "pathe";
+
+// src/ai/tar.ts
+import { gzipSync } from "node:zlib";
+var BLOCK = 512;
+var NAME_MAX = 100;
+var encoder = new TextEncoder;
+var octal = (header, offset, length, value) => {
+  const text = value.toString(8).padStart(length - 1, "0");
+  header.set(encoder.encode(text), offset);
+  header[offset + length - 1] = 0;
+};
+var text = (header, offset, value) => {
+  header.set(encoder.encode(value), offset);
+};
+var fileHeader = (entry) => {
+  const header = new Uint8Array(BLOCK);
+  text(header, 0, entry.path);
+  octal(header, 100, 8, entry.executable ? 493 : 420);
+  octal(header, 108, 8, 0);
+  octal(header, 116, 8, 0);
+  octal(header, 124, 12, entry.content.byteLength);
+  octal(header, 136, 12, 0);
+  text(header, 156, "0");
+  text(header, 257, "ustar");
+  header[262] = 0;
+  text(header, 263, "00");
+  octal(header, 329, 8, 0);
+  octal(header, 337, 8, 0);
+  header.fill(32, 148, 156);
+  let sum = 0;
+  for (const byte of header) {
+    sum += byte;
+  }
+  text(header, 148, sum.toString(8).padStart(6, "0"));
+  header[154] = 0;
+  header[155] = 32;
+  return header;
+};
+var buildTarGz = (entries) => {
+  const blocks = [];
+  for (const entry of entries) {
+    if (encoder.encode(entry.path).byteLength > NAME_MAX) {
+      throw new Error(`tar path exceeds ${NAME_MAX} bytes: ${entry.path}`);
+    }
+    if (entry.path.startsWith("/") || entry.path.split("/").includes("..")) {
+      throw new Error(`tar path must be archive-relative: ${entry.path}`);
+    }
+    blocks.push(fileHeader(entry), entry.content);
+    const overhang = entry.content.byteLength % BLOCK;
+    if (overhang > 0) {
+      blocks.push(new Uint8Array(BLOCK - overhang));
+    }
+  }
+  blocks.push(new Uint8Array(BLOCK * 2));
+  const total = blocks.reduce((sum, block) => sum + block.byteLength, 0);
+  const tar = new Uint8Array(total);
+  let offset = 0;
+  for (const block of blocks) {
+    tar.set(block, offset);
+    offset += block.byteLength;
+  }
+  return new Uint8Array(gzipSync(tar, { level: 9 }));
+};
+
+// src/ai/skills.ts
+var AGENT_SKILLS_DIR = "/.well-known/agent-skills";
+var AGENT_SKILLS_SCHEMA = "https://schemas.agentskills.io/discovery/0.2.0/schema.json";
+var SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var SKILL_NAME_MAX = 64;
+var DESCRIPTION_MAX2 = 1024;
+var sha256 = (content) => `sha256:${createHash2("sha256").update(content).digest("hex")}`;
+var collectEntries = async (dir, prefix = "") => {
+  const entries = [];
+  const items = await readdir(dir, { withFileTypes: true });
+  for (const item of items.toSorted((a, b) => a.name < b.name ? -1 : 1)) {
+    if (item.name.startsWith(".")) {
+      continue;
+    }
+    const path = join18(dir, item.name);
+    const relative12 = prefix ? `${prefix}/${item.name}` : item.name;
+    if (item.isDirectory()) {
+      entries.push(...await collectEntries(path, relative12));
+    } else if (item.isFile()) {
+      const [content, info] = await Promise.all([readFile10(path), stat2(path)]);
+      entries.push({
+        content: new Uint8Array(content),
+        executable: (info.mode & 64) !== 0,
+        path: relative12
+      });
+    }
+  }
+  return entries;
+};
+var skillMeta = (raw, dirName) => {
+  let data;
+  try {
+    ({ data } = frontmatter_default(raw));
+  } catch {
+    return {
+      meta: null,
+      warning: `Skill "${dirName}" has unparsable SKILL.md frontmatter; skipped.`
+    };
+  }
+  const name = typeof data.name === "string" ? data.name : "";
+  const description = typeof data.description === "string" ? data.description : "";
+  if (!(name && description)) {
+    return {
+      meta: null,
+      warning: `Skill "${dirName}" is missing the required "name"/"description" frontmatter; skipped.`
+    };
+  }
+  if (!SKILL_NAME.test(name) || name.length > SKILL_NAME_MAX) {
+    return {
+      meta: null,
+      warning: `Skill "${dirName}" has an invalid name "${name}" (lowercase alphanumerics and single hyphens, max 64 chars); skipped.`
+    };
+  }
+  return {
+    meta: { description: description.slice(0, DESCRIPTION_MAX2), name }
+  };
+};
+var collectSkills = async (dir) => {
+  const skills = [];
+  const warnings = [];
+  const items = await readdir(dir, { withFileTypes: true });
+  for (const item of items.toSorted((a, b) => a.name < b.name ? -1 : 1)) {
+    if (!item.isDirectory() || item.name.startsWith(".")) {
+      continue;
+    }
+    const entries = await collectEntries(join18(dir, item.name));
+    const skillMd = entries.find((entry) => entry.path === "SKILL.md");
+    if (!skillMd) {
+      continue;
+    }
+    const { meta, warning } = skillMeta(new TextDecoder().decode(skillMd.content), item.name);
+    if (!meta) {
+      if (warning) {
+        warnings.push(warning);
+      }
+      continue;
+    }
+    const single = entries.length === 1;
+    const content = single ? skillMd.content : buildTarGz(entries);
+    skills.push({
+      content,
+      description: meta.description,
+      digest: sha256(content),
+      name: meta.name,
+      path: single ? `${meta.name}/SKILL.md` : `${meta.name}.tar.gz`,
+      type: single ? "skill-md" : "archive"
+    });
+  }
+  return { skills, warnings };
+};
+var buildSkillsIndex = (skills, config) => {
+  const deployBase = normalizeBasePath(config.deployment.base);
+  const index = {
+    $schema: AGENT_SKILLS_SCHEMA,
+    skills: skills.map((skill) => ({
+      description: skill.description,
+      digest: skill.digest,
+      name: skill.name,
+      type: skill.type,
+      url: `${deployBase}${AGENT_SKILLS_DIR}/${skill.path}`
+    }))
+  };
+  return `${JSON.stringify(index, null, 2)}
+`;
+};
+
+// src/ai/web-bot-auth.ts
+var SIGNATURES_DIRECTORY_PATH = "/.well-known/http-message-signatures-directory";
+var SIGNATURES_DIRECTORY_TYPE = "application/http-message-signatures-directory+json";
+var buildSignaturesDirectory = (config) => {
+  const { keys } = config.ai.webBotAuth;
+  if (keys.length === 0) {
+    return null;
+  }
+  return `${JSON.stringify({ keys }, null, 2)}
+`;
+};
+
+// src/core/gitignore.ts
+import { existsSync as existsSync10 } from "node:fs";
+import { readFile as readFile11, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join19 } from "pathe";
 var gitignoreKey = (line) => line.trim().replace(/\/+$/u, "");
 var ensureGitignore = async (root, entries) => {
-  const path = join18(root, ".gitignore");
-  const existing = existsSync9(path) ? await readFile9(path, "utf-8") : "";
+  const path = join19(root, ".gitignore");
+  const existing = existsSync10(path) ? await readFile11(path, "utf-8") : "";
   const present = new Set(existing.split(`
 `).flatMap((line) => {
     const key = gitignoreKey(line);
@@ -12238,13 +12952,31 @@ var HEADER_RULES = [
     underBasePath: false
   }
 ];
-var buildNetlifyHeaders = (config) => {
+var buildNetlifyHeaders = (config, homeLinkHeader) => {
   const deployBase = normalizeBasePath(config.deployment.base);
-  return `${HEADER_RULES.map((rule) => {
+  const rules = HEADER_RULES.map((rule) => {
     const prefix = rule.underBasePath ? `${deployBase}${config.basePath}` : deployBase;
     return `${prefix}/*.${rule.ext}
   Content-Type: ${rule.contentType}`;
-  }).join(`
+  });
+  if (homeLinkHeader) {
+    rules.push(`${deployBase}/
+  Link: ${homeLinkHeader}`);
+  }
+  if (hasApiCatalog(config)) {
+    rules.push(`${deployBase}${API_CATALOG_PATH}
+  Content-Type: ${API_CATALOG_TYPE}`);
+  }
+  if (config.ai.webBotAuth.keys.length > 0) {
+    rules.push(`${deployBase}${SIGNATURES_DIRECTORY_PATH}
+  Content-Type: ${SIGNATURES_DIRECTORY_TYPE}`);
+  }
+  if (config.ai.skills) {
+    rules.push(`${deployBase}/.well-known/agent-skills/*.md
+  Content-Type: text/markdown; charset=utf-8`, `${deployBase}/.well-known/agent-skills/*.tar.gz
+  Content-Type: application/gzip`);
+  }
+  return `${rules.join(`
 `)}
 `;
 };
@@ -12284,7 +13016,7 @@ var buildRobots = (project) => {
 };
 
 // src/astro/pages.ts
-import { extname as extname5, relative as relative11 } from "pathe";
+import { extname as extname6, relative as relative12 } from "pathe";
 import { glob as glob4, globSync } from "tinyglobby";
 var PAGE_GLOB = ["**/*.astro"];
 var isPrivatePage = (rel) => rel.split("/").some((segment) => segment.startsWith("_"));
@@ -12292,11 +13024,11 @@ var toPageRoutes = (pagesRoot, files) => {
   files.sort();
   const routes = [];
   for (const file of files) {
-    const rel = relative11(pagesRoot, file);
+    const rel = relative12(pagesRoot, file);
     if (isPrivatePage(rel)) {
       continue;
     }
-    const withoutExt = rel.slice(0, rel.length - extname5(rel).length);
+    const withoutExt = rel.slice(0, rel.length - extname6(rel).length);
     const parts = withoutExt.split("/");
     if (parts.at(-1) === "index") {
       parts.pop();
@@ -12408,8 +13140,102 @@ ${urls.join(`
 `;
 };
 
+// src/deploy/vercel-negotiation.ts
+var ACCEPT_MARKDOWN_HEADER_VALUE = "(.*,)?\\s*text/(x-)?markdown(\\s*[;,].*)?$";
+var ACCEPT_MARKDOWN_CONDITION = [
+  { key: "accept", type: "header", value: ACCEPT_MARKDOWN_HEADER_VALUE }
+];
+var VARY_ACCEPT = { vary: "Accept" };
+var MAX_ALTERNATION_LENGTH = 3900;
+var REGEX_SPECIALS = /[$()*+.?[\]^{|}\\]/gu;
+var routePattern = (route) => encodeURI(route).replace(REGEX_SPECIALS, "\\$&");
+var chunkPatterns = (patterns) => {
+  const chunks = [];
+  let current = [];
+  let length = 0;
+  for (const pattern of patterns) {
+    if (current.length > 0 && length + pattern.length + 1 > MAX_ALTERNATION_LENGTH) {
+      chunks.push(current);
+      current = [];
+      length = 0;
+    }
+    current.push(pattern);
+    length += pattern.length + 1;
+  }
+  if (current.length > 0) {
+    chunks.push(current);
+  }
+  return chunks;
+};
+var buildNegotiationRoutes = (routePaths) => {
+  const home = routePaths.includes("/");
+  const rest = routePaths.filter((path) => path !== "/").map((path) => routePattern(path));
+  const chunks = chunkPatterns(rest);
+  const rewriteRoutes = home ? [
+    {
+      dest: "/index.md",
+      has: ACCEPT_MARKDOWN_CONDITION,
+      headers: VARY_ACCEPT,
+      src: "^/$"
+    }
+  ] : [];
+  for (const chunk of chunks) {
+    rewriteRoutes.push({
+      dest: "$1.md",
+      has: ACCEPT_MARKDOWN_CONDITION,
+      headers: VARY_ACCEPT,
+      src: `^(${chunk.join("|")})/?$`
+    });
+  }
+  const headerChunks = chunkPatterns(home ? ["/", ...rest] : rest);
+  const headerRoutes = headerChunks.map((chunk) => ({
+    continue: true,
+    headers: VARY_ACCEPT,
+    src: `^(?:${chunk.join("|")})/?$`
+  }));
+  return { headerRoutes, rewriteRoutes };
+};
+var HOME_SRC = "^/$";
+var isNegotiationRoute = (route) => route.has?.some((condition) => condition.value === ACCEPT_MARKDOWN_HEADER_VALUE) === true || route.continue === true && route.headers?.vary === "Accept" && typeof route.src === "string" && Object.keys(route).length === 3 || route.continue === true && typeof route.headers?.link === "string" && route.src === HOME_SRC && Object.keys(route).length === 3;
+var injectNegotiationRoutes = (configText, routePaths, homeLinkHeader, contentTypeOverrides) => {
+  const overrideEntries = Object.entries(contentTypeOverrides ?? {});
+  if (routePaths.length === 0 && !homeLinkHeader && overrideEntries.length === 0) {
+    return null;
+  }
+  let config;
+  try {
+    config = JSON.parse(configText);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(config.routes)) {
+    return null;
+  }
+  for (const [path, contentType] of overrideEntries) {
+    config.overrides = { ...config.overrides, [path]: { contentType } };
+  }
+  const routes = config.routes.filter((route) => !isNegotiationRoute(route));
+  const filesystemIndex = routes.findIndex((route) => route.handle === "filesystem");
+  if (filesystemIndex === -1) {
+    return null;
+  }
+  const { headerRoutes, rewriteRoutes } = buildNegotiationRoutes(routePaths);
+  if (homeLinkHeader) {
+    headerRoutes.push({
+      continue: true,
+      headers: { link: homeLinkHeader },
+      src: HOME_SRC
+    });
+  }
+  routes.splice(filesystemIndex + 1, 0, ...headerRoutes);
+  routes.splice(filesystemIndex, 0, ...rewriteRoutes);
+  config.routes = routes;
+  return `${JSON.stringify(config, null, "\t")}
+`;
+};
+
 // src/search/build.ts
-import { join as join19 } from "pathe";
+import { join as join20 } from "pathe";
 var buildSearchIndex = async (outDir) => {
   const pagefind = await import("pagefind");
   const { index } = await pagefind.createIndex({});
@@ -12417,7 +13243,7 @@ var buildSearchIndex = async (outDir) => {
     throw new Error("Failed to create Pagefind index.");
   }
   const result = await index.addDirectory({ path: outDir });
-  await index.writeFiles({ outputPath: join19(outDir, "pagefind") });
+  await index.writeFiles({ outputPath: join20(outDir, "pagefind") });
   await pagefind.close();
   return result.page_count;
 };
@@ -12640,14 +13466,14 @@ var syncSearchProvider = async (project, reporter) => {
 
 // src/cli/dev-lock.ts
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   mkdirSync,
   readFileSync as readFileSync5,
   rmSync,
   writeFileSync
 } from "node:fs";
-import { join as join20 } from "pathe";
-var lockPath = (outDir) => join20(outDir, "dev.lock");
+import { join as join21 } from "pathe";
+var lockPath = (outDir) => join21(outDir, "dev.lock");
 var isValidPid = (pid) => typeof pid === "number" && Number.isInteger(pid) && pid > 0;
 var parseLock = (raw) => {
   let data;
@@ -12677,7 +13503,7 @@ var isProcessAlive = (pid) => {
 };
 var readDevLock = (outDir) => {
   const path = lockPath(outDir);
-  if (!existsSync10(path)) {
+  if (!existsSync11(path)) {
     return null;
   }
   const lock = parseLock(readFileSync5(path, "utf-8"));
@@ -12701,7 +13527,7 @@ class DevLockHeldError extends Error {
 }
 var ownsLock = (outDir) => {
   const path = lockPath(outDir);
-  if (!existsSync10(path)) {
+  if (!existsSync11(path)) {
     return false;
   }
   try {
@@ -12758,12 +13584,12 @@ var refuseIfDevRunning = (root, action, options = {}) => {
 };
 
 // src/astro/generate.ts
-import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync14, readFileSync as readFileSync9, realpathSync } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync16, readFileSync as readFileSync9, realpathSync } from "node:fs";
 import {
   lstat,
   mkdir as mkdir6,
-  readFile as readFile14,
+  readFile as readFile16,
   readlink,
   realpath,
   rename,
@@ -12773,7 +13599,7 @@ import {
 } from "node:fs/promises";
 import { createRequire as createRequire5 } from "node:module";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
-import { basename as basename3, dirname as dirname9, join as join26, normalize as normalize3, relative as relative13, resolve as resolve7 } from "pathe";
+import { basename as basename3, dirname as dirname10, join as join28, normalize as normalize3, relative as relative14, resolve as resolve8 } from "pathe";
 import { glob as glob7 } from "tinyglobby";
 
 // src/ai/ask-data.ts
@@ -12784,6 +13610,7 @@ var buildAskData = async (project) => {
     includeWhenDisabled: true
   });
   return {
+    defaultLocale: project.config.i18n?.defaultLocale,
     documents: documents.map((doc) => ({
       content: doc.content,
       description: doc.description,
@@ -12796,7 +13623,7 @@ var buildAskData = async (project) => {
 };
 
 // src/ai/markdown.ts
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 var agentMarkdown = (entry) => entry.md ?? entry.mdx;
 var buildRawMarkdown = async (project) => {
   const pageById = new Map(project.graph.pages.map((page) => [page.id, page]));
@@ -12809,10 +13636,19 @@ var buildRawMarkdown = async (project) => {
     if (page) {
       return await readEntryText(project, page);
     }
-    return route.sourcePath ? await readFile10(route.sourcePath, "utf-8") : "";
+    return route.sourcePath ? await readFile12(route.sourcePath, "utf-8") : "";
   };
   const entries = await Promise.all(project.manifest.routes.map(async (route) => {
-    const source = applyAgentVisibility(await readRoute(route));
+    let text2 = await readRoute(route);
+    if (route.sourcePath) {
+      text2 = rewriteRelativeImages({
+        deployBase: project.config.deployment.base,
+        projectRoot: project.context.root,
+        source: text2,
+        sourcePath: route.sourcePath
+      });
+    }
+    const source = applyAgentVisibility(text2);
     const md = downlevelComponents(source, components, frontmatter_default(source).data);
     const entry = md === source ? { mdx: source } : { md, mdx: source };
     return [route.path, entry];
@@ -12851,6 +13687,7 @@ var buildMcpData = async (project) => {
   }
   return {
     base: normalizeBasePath(config.deployment.base),
+    defaultLocale: config.i18n?.defaultLocale,
     documents: documents.map((doc) => ({
       content: doc.content,
       description: doc.description,
@@ -12910,19 +13747,42 @@ var buildMcpDiscovery = (input) => ({
     }
   ]
 });
-var buildMcpServerCard = (input) => ({
-  description: `Model Context Protocol server for the ${input.name} documentation.`,
-  name: input.name,
-  tools: MCP_TOOLS.map((tool) => ({
-    annotations: tool.annotations,
-    description: tool.description,
-    name: tool.name,
-    title: tool.title
-  })),
-  transport: "streamable-http",
-  url: serverUrl(input),
-  version: input.version
-});
+var SERVER_CARD_SCHEMA = "https://static.modelcontextprotocol.io/schemas/v1/server-card.schema.json";
+var CARD_TEXT_MAX = 100;
+var truncate = (text2) => text2.length > CARD_TEXT_MAX ? `${text2.slice(0, CARD_TEXT_MAX - 1)}…` : text2;
+var reverseDnsName = (input) => {
+  let namespace = "localhost";
+  if (input.site) {
+    try {
+      namespace = new URL(input.site).hostname.split(".").toReversed().join(".");
+    } catch {}
+  }
+  return `${namespace}/${slugify(input.name) || "docs"}`;
+};
+var HTTP_URL2 = /^https?:\/\//u;
+var buildMcpServerCard = (input) => {
+  const url = serverUrl(input);
+  return {
+    $schema: SERVER_CARD_SCHEMA,
+    capabilities: { tools: { listChanged: false } },
+    description: truncate(`Model Context Protocol server for the ${input.name} documentation.`),
+    name: reverseDnsName(input),
+    ...HTTP_URL2.test(url) ? { remotes: [{ type: "streamable-http", url }] } : {},
+    serverInfo: { name: input.name, version: input.version },
+    title: truncate(input.name),
+    tools: MCP_TOOLS.map((tool) => ({
+      annotations: tool.annotations,
+      description: tool.description,
+      name: tool.name,
+      title: tool.title
+    })),
+    transport: "streamable-http",
+    transports: [{ endpoint: url, type: "streamable-http" }],
+    url,
+    version: input.version,
+    ...input.site ? { websiteUrl: trimEnd(input.site, "/") } : {}
+  };
+};
 
 // src/core/builtin-tags.ts
 var BUILTIN_MDX_TAGS = new Set([
@@ -12989,8 +13849,8 @@ var validateUsedComponents = (pages, extraTags, registryNames) => {
 };
 
 // src/core/component-overrides.ts
-import { existsSync as existsSync11 } from "node:fs";
-import { dirname as dirname7, extname as extname6, isAbsolute as isAbsolute6, resolve as resolve5 } from "pathe";
+import { existsSync as existsSync12 } from "node:fs";
+import { dirname as dirname8, extname as extname7, isAbsolute as isAbsolute6, resolve as resolve6 } from "pathe";
 import ts from "typescript";
 var GROUPS = ["mdx", "layout", "islands"];
 var GROUP_SET = new Set(GROUPS);
@@ -13082,24 +13942,24 @@ var findDefaultExportObject = (sourceFile) => {
 var probeExtension = (base) => {
   for (const extension of COMPONENT_EXTS) {
     const candidate = `${base}.${extension}`;
-    if (existsSync11(candidate)) {
+    if (existsSync12(candidate)) {
       return candidate;
     }
   }
   return null;
 };
 var toImport = (specifier, imported, dir) => {
-  const relative12 = specifier.startsWith(".") || isAbsolute6(specifier);
+  const relative13 = specifier.startsWith(".") || isAbsolute6(specifier);
   let path = specifier;
-  let extension = extname6(specifier).slice(1).toLowerCase();
-  if (relative12) {
-    const absolute = isAbsolute6(specifier) ? specifier : resolve5(dir, specifier);
+  let extension = extname7(specifier).slice(1).toLowerCase();
+  if (relative13) {
+    const absolute = isAbsolute6(specifier) ? specifier : resolve6(dir, specifier);
     if (extension) {
       path = absolute;
     } else {
       const probed = probeExtension(absolute);
       path = probed ?? absolute;
-      extension = probed ? extname6(probed).slice(1).toLowerCase() : "";
+      extension = probed ? extname7(probed).slice(1).toLowerCase() : "";
     }
   }
   return {
@@ -13248,7 +14108,7 @@ var analyzeComponentOverrides = (source, filePath) => {
     return result;
   }
   const imports = collectImports(sourceFile);
-  const dir = dirname7(filePath);
+  const dir = dirname8(filePath);
   for (const property of object.properties) {
     collectGroupOverrides(property, imports, dir, result);
   }
@@ -13256,16 +14116,16 @@ var analyzeComponentOverrides = (source, filePath) => {
 };
 
 // src/core/tsconfig-aliases.ts
-import { existsSync as existsSync12, readFileSync as readFileSync6, statSync } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync6, statSync } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
-import { dirname as dirname8, isAbsolute as isAbsolute7, join as join21, resolve as resolve6 } from "pathe";
-var scanJsonChar = (text, index, inString) => {
-  const char = text[index];
+import { dirname as dirname9, isAbsolute as isAbsolute7, join as join22, resolve as resolve7 } from "pathe";
+var scanJsonChar = (text2, index, inString) => {
+  const char = text2[index];
   if (inString) {
     if (char === "\\") {
       return {
-        append: char + (text[index + 1] ?? ""),
+        append: char + (text2[index + 1] ?? ""),
         inString: true,
         next: index + 2
       };
@@ -13275,35 +14135,35 @@ var scanJsonChar = (text, index, inString) => {
   if (char === '"') {
     return { append: char, inString: true, next: index + 1 };
   }
-  if (char === "/" && text[index + 1] === "/") {
-    const newline = text.indexOf(`
+  if (char === "/" && text2[index + 1] === "/") {
+    const newline = text2.indexOf(`
 `, index + 2);
     return {
       append: "",
       inString: false,
-      next: newline === -1 ? text.length : newline
+      next: newline === -1 ? text2.length : newline
     };
   }
-  if (char === "/" && text[index + 1] === "*") {
-    const end = text.indexOf("*/", index + 2);
+  if (char === "/" && text2[index + 1] === "*") {
+    const end = text2.indexOf("*/", index + 2);
     return {
       append: "",
       inString: false,
-      next: end === -1 ? text.length : end + 2
+      next: end === -1 ? text2.length : end + 2
     };
   }
   return { append: char ?? "", inString: false, next: index + 1 };
 };
-var stripJsonComments = (text) => {
+var stripJsonComments = (text2) => {
   let out = "";
   let inString = false;
   let index = 0;
-  while (index < text.length) {
+  while (index < text2.length) {
     const {
       append,
       inString: nextInString,
       next
-    } = scanJsonChar(text, index, inString);
+    } = scanJsonChar(text2, index, inString);
     out += append;
     inString = nextInString;
     index = next;
@@ -13311,9 +14171,9 @@ var stripJsonComments = (text) => {
   return out;
 };
 var TRAILING_COMMA = /,(?<rest>\s*[}\]])/gu;
-var parseJsonc = (text) => {
+var parseJsonc = (text2) => {
   try {
-    const cleaned = stripJsonComments(text).replaceAll(TRAILING_COMMA, "$<rest>");
+    const cleaned = stripJsonComments(text2).replaceAll(TRAILING_COMMA, "$<rest>");
     const value = JSON.parse(cleaned);
     return value && typeof value === "object" && !Array.isArray(value) ? value : null;
   } catch {
@@ -13329,15 +14189,15 @@ var isFile = (path) => {
 };
 var resolveExtends = (spec, fromDir) => {
   if (spec.startsWith(".") || isAbsolute7(spec)) {
-    const candidates = spec.endsWith(".json") ? [resolve6(fromDir, spec)] : [
-      resolve6(fromDir, `${spec}.json`),
-      resolve6(fromDir, spec, "tsconfig.json"),
-      resolve6(fromDir, spec)
+    const candidates = spec.endsWith(".json") ? [resolve7(fromDir, spec)] : [
+      resolve7(fromDir, `${spec}.json`),
+      resolve7(fromDir, spec, "tsconfig.json"),
+      resolve7(fromDir, spec)
     ];
     return candidates.find(isFile) ?? null;
   }
   try {
-    const requireFromDir = createRequire3(pathToFileURL2(join21(fromDir, "_.js")).href);
+    const requireFromDir = createRequire3(pathToFileURL2(join22(fromDir, "_.js")).href);
     for (const sub of [`${spec}/tsconfig.json`, spec]) {
       try {
         return requireFromDir.resolve(sub);
@@ -13347,7 +14207,7 @@ var resolveExtends = (spec, fromDir) => {
   return null;
 };
 var loadPaths = (file, seen) => {
-  if (seen.has(file) || !existsSync12(file)) {
+  if (seen.has(file) || !existsSync13(file)) {
     return null;
   }
   seen.add(file);
@@ -13359,7 +14219,7 @@ var loadPaths = (file, seen) => {
   if (options.paths && typeof options.paths === "object") {
     const baseUrl = typeof options.baseUrl === "string" ? options.baseUrl : ".";
     return {
-      baseDir: resolve6(dirname8(file), baseUrl),
+      baseDir: resolve7(dirname9(file), baseUrl),
       paths: options.paths
     };
   }
@@ -13368,7 +14228,7 @@ var loadPaths = (file, seen) => {
     if (typeof base !== "string") {
       continue;
     }
-    const resolved = resolveExtends(base, dirname8(file));
+    const resolved = resolveExtends(base, dirname9(file));
     const found = resolved ? loadPaths(resolved, seen) : null;
     if (found) {
       return found;
@@ -13386,10 +14246,10 @@ var toAlias = (key, value, baseDir) => {
   if (find === "" || find === "*") {
     return null;
   }
-  return { find, replacement: resolve6(baseDir, target) };
+  return { find, replacement: resolve7(baseDir, target) };
 };
 var resolveTsconfigAliases = (root) => {
-  const entry = ["tsconfig.json", "jsconfig.json"].map((name) => join21(root, name)).find((file) => existsSync12(file));
+  const entry = ["tsconfig.json", "jsconfig.json"].map((name) => join22(root, name)).find((file) => existsSync13(file));
   if (!entry) {
     return {};
   }
@@ -13407,24 +14267,126 @@ var resolveTsconfigAliases = (root) => {
   return aliases;
 };
 
+// src/og/derive.ts
+import { existsSync as existsSync14 } from "node:fs";
+import { isAbsolute as isAbsolute8, join as join23 } from "pathe";
+var CARD_WEIGHTS = [400, 600];
+var absoluteSrc = (root, src) => isAbsolute8(src) ? src : join23(root, src);
+var googleWeights = (weights) => {
+  const numbers = weights.filter((weight) => typeof weight === "number");
+  const used = numbers.filter((weight) => CARD_WEIGHTS.includes(weight));
+  if (used.length > 0) {
+    return used;
+  }
+  if (numbers.length > 0) {
+    return numbers;
+  }
+  const [first] = weights;
+  return weights.length === 1 && typeof first === "string" ? first : undefined;
+};
+var googleOgFont = (name, weights) => {
+  const weight = googleWeights(weights);
+  return weight === undefined ? { name } : { name, weight };
+};
+var localOgFonts = (font, root) => font.variants.map((variant) => ({
+  name: font.name,
+  src: absoluteSrc(root, variant.src),
+  ...typeof variant.weight === "number" ? { weight: variant.weight } : {},
+  ...variant.style === "normal" || variant.style === "italic" ? { style: variant.style } : {}
+}));
+var roleFonts = (value, root) => {
+  if (typeof value === "string") {
+    if (!isFontSlug(value)) {
+      return null;
+    }
+    const def = GOOGLE_FONTS[value];
+    return [googleOgFont(def.family, def.weights)];
+  }
+  if ("variants" in value) {
+    return localOgFonts(value, root);
+  }
+  const remote = value;
+  if ((remote.provider ?? "google") !== "google") {
+    return null;
+  }
+  return [googleOgFont(remote.name, remote.weights ?? CARD_WEIGHTS)];
+};
+var roleFamily = (value) => {
+  if (typeof value === "string") {
+    return isFontSlug(value) ? GOOGLE_FONTS[value].family : null;
+  }
+  return value.name;
+};
+var deriveOgFonts = (fonts, root) => {
+  const derived = [];
+  const seen = new Set;
+  const families = {};
+  const roles = [
+    ["title", fonts?.display],
+    ["body", fonts?.body]
+  ];
+  for (const [role, value] of roles) {
+    if (value === undefined) {
+      continue;
+    }
+    const roleEntries = roleFonts(value, root);
+    if (!roleEntries) {
+      continue;
+    }
+    families[role] = roleFamily(value) ?? undefined;
+    for (const entry of roleEntries) {
+      const key = JSON.stringify(entry);
+      if (!seen.has(key)) {
+        seen.add(key);
+        derived.push(entry);
+      }
+    }
+  }
+  return {
+    fonts: derived,
+    ...families.title || families.body ? { families } : {}
+  };
+};
+var resolveOgFontSources = (fonts, root) => fonts.map((font) => typeof font !== "string" && ("src" in font) ? { ...font, src: absoluteSrc(root, font.src) } : font);
+var resolveOgFonts = (options, root) => {
+  if (options.ogFonts) {
+    return { fonts: resolveOgFontSources(options.ogFonts, root) };
+  }
+  return options.themeFontsConfigured ? deriveOgFonts(options.themeFonts, root) : { fonts: [] };
+};
+var missingFontFiles = (options, root) => {
+  const sources = [];
+  for (const value of Object.values(options.themeFonts ?? {})) {
+    if (typeof value !== "string" && "variants" in value) {
+      sources.push(...value.variants.map((variant) => absoluteSrc(root, variant.src)));
+    }
+  }
+  for (const font of options.ogFonts) {
+    if (typeof font !== "string" && "src" in font) {
+      sources.push(absoluteSrc(root, font.src));
+    }
+  }
+  return [...new Set(sources)].filter((path) => !existsSync14(path));
+};
+
 // src/og/logo.ts
-import { existsSync as existsSync13, readFileSync as readFileSync7 } from "node:fs";
-import { join as join22 } from "pathe";
+import { existsSync as existsSync15, readFileSync as readFileSync7 } from "node:fs";
+import { join as join24 } from "pathe";
 var resolveOgLogo = (project, source) => {
   if (!source?.toLowerCase().endsWith(".svg")) {
     return;
   }
-  const relative12 = source.replace(/^\//u, "");
+  const relative13 = source.replace(/^\//u, "");
   const file = [
-    join22(project.context.root, "public", relative12),
-    join22(project.context.root, relative12)
-  ].find((path) => existsSync13(path));
+    join24(project.context.root, "public", relative13),
+    join24(project.context.root, relative13)
+  ].find((path) => existsSync15(path));
   return file ? readFileSync7(file, "utf-8") : undefined;
 };
 
 // src/openapi/scalar.ts
-import { readFile as readFile11 } from "node:fs/promises";
-import { isAbsolute as isAbsolute8, join as join23 } from "pathe";
+import { readFile as readFile13 } from "node:fs/promises";
+import { isAbsolute as isAbsolute9, join as join25 } from "pathe";
 
 // src/theme/palette.ts
 var FALLBACK_ACCENT = "oklch(0.62 0.16 250)";
@@ -13530,9 +14492,9 @@ var specConfiguration = async (spec, root) => {
   if (URL_SPEC2.test(spec)) {
     return { config: { url: spec } };
   }
-  const absolute = isAbsolute8(spec) ? spec : join23(root, spec);
+  const absolute = isAbsolute9(spec) ? spec : join25(root, spec);
   try {
-    return { config: { content: await readFile11(absolute, "utf-8") } };
+    return { config: { content: await readFile13(absolute, "utf-8") } };
   } catch {
     return {
       config: { url: spec },
@@ -14019,19 +14981,29 @@ blume-diff {
    even though its chrome wrapper is not-prose. */
 .prose :where(pre:not(.twoslash, .twoslash pre, blume-panel-tabs *) > code) {
   display: block;
-  overflow-x: auto;
-  padding: 0 1.25rem;
-  /* The scroller is only as tall as the code, so an overlay scrollbar would
-     draw on top of the last line; hide it (wheel/trackpad/keyboard scrolling
-     still works). */
-  scrollbar-width: none;
+  /* Tall blocks scroll vertically in place instead of taking the page. Both
+     axes live on the code element for the same reason: the pre stays static
+     so the header bar and copy button never drift with the scroll. */
+  max-height: 24rem;
+  overflow: auto;
+  /* The small bottom inset keeps the horizontal thumb off the last line's
+     descenders now that scrollbars are visible. */
+  padding: 0 1.25rem 0.375rem;
+  /* Thin theme-colored scrollbars, matching the sidebar treatment, so a
+     height-capped block reads as scrollable instead of simply ending.
+     Safari before 18.2 supports neither property and falls back to the
+     platform-default scrollbar — acceptable, since macOS overlays it. */
+  scrollbar-color: var(--blume-border) transparent;
+  scrollbar-width: thin;
 }
 
-.prose
-  :where(
-    pre:not(.twoslash, .twoslash pre, blume-panel-tabs *) > code
-  )::-webkit-scrollbar {
-  display: none;
+/* The dark border token is too close to the page background to read as a
+   scrollbar thumb; derive a brighter one from the muted foreground instead. */
+:root[data-theme="dark"]
+  .prose
+  :where(pre:not(.twoslash, .twoslash pre, blume-panel-tabs *) > code) {
+  scrollbar-color: color-mix(in oklab, var(--blume-muted-foreground) 55%, transparent)
+    transparent;
 }
 
 /* Word wrap (markdown.code.wrap): long lines wrap instead of scrolling. The
@@ -14099,6 +15071,10 @@ pre.blume-source {
 
 pre.blume-source > code {
   flex: 1;
+  /* The pane's measured height is authoritative (it can exceed the prose
+     24rem cap), so undo the generic prose max-height: the code must fill
+     whatever height the tab was given. */
+  max-height: none;
   min-height: 0;
   overflow: auto;
 }
@@ -14280,6 +15256,13 @@ pre:has(.line.focused):hover .line:not(.focused) {
     display: none !important;
   }
 
+  /* Paper can't scroll: uncap the code scroller so long blocks print in
+     full, same as tab panels are force-expanded below. */
+  .prose :where(pre:not(.twoslash, .twoslash pre, blume-panel-tabs *) > code) {
+    max-height: none;
+    overflow: visible;
+  }
+
   #blume-content {
     padding: 0 !important;
   }
@@ -14523,13 +15506,13 @@ export const layoutOverrides = { ...(overrides.layout ?? {})${layoutEntries.leng
 };
 
 // src/astro/examples.ts
-import { readFile as readFile13 } from "node:fs/promises";
-import { join as join25, relative as relative12 } from "pathe";
+import { readFile as readFile15 } from "node:fs/promises";
+import { join as join27, relative as relative13 } from "pathe";
 import { glob as glob6 } from "tinyglobby";
 
 // src/astro/islands.ts
-import { readFile as readFile12 } from "node:fs/promises";
-import { basename as basename2, join as join24 } from "pathe";
+import { readFile as readFile14 } from "node:fs/promises";
+import { basename as basename2, join as join26 } from "pathe";
 import { glob as glob5 } from "tinyglobby";
 var DEFAULT_CLIENT = "visible";
 var VALID_MODES = new Set([
@@ -14558,14 +15541,14 @@ var readClientMode = (source, file, warnings) => {
   return mode;
 };
 var discoverIslands = async (root) => {
-  const dir = join24(root, "islands");
+  const dir = join26(root, "islands");
   const matches2 = await glob5(["**/*.{jsx,svelte,tsx,vue}"], {
     absolute: true,
     cwd: dir,
     onlyFiles: true
   });
   const files = matches2.toSorted();
-  const sources = await Promise.all(files.map((file) => readFile12(file, "utf-8")));
+  const sources = await Promise.all(files.map((file) => readFile14(file, "utf-8")));
   const islands = [];
   const warnings = [];
   const seen = new Map;
@@ -14621,14 +15604,14 @@ var splitGlobBase = (pattern) => {
 };
 var discoverExamples = async (root, pattern = "examples") => {
   const { base, rest } = GLOB_MAGIC.test(pattern) ? splitGlobBase(pattern) : { base: pattern, rest: DEFAULT_EXAMPLE_GLOB };
-  const dir = join25(root, base);
+  const dir = join27(root, base);
   const matches2 = await glob6([rest], {
     absolute: true,
     cwd: dir,
     onlyFiles: true
   });
   const files = matches2.toSorted();
-  const sources = await Promise.all(files.map((file) => readFile13(file, "utf-8")));
+  const sources = await Promise.all(files.map((file) => readFile15(file, "utf-8")));
   const examples = [];
   const warnings = [];
   const seen = new Map;
@@ -14638,7 +15621,7 @@ var discoverExamples = async (root, pattern = "examples") => {
     if (!(ext && framework)) {
       return;
     }
-    const path = relative12(dir, file).slice(0, -(ext.length + 1));
+    const path = relative13(dir, file).slice(0, -(ext.length + 1));
     const existing = seen.get(path);
     if (existing) {
       warnings.push(`Two examples both resolve to "${path}" ("${existing}" and "${file}"); ignoring the second. Give them distinct paths.`);
@@ -14665,10 +15648,10 @@ var exampleMarkdownLookup = (examples) => Object.fromEntries(examples.map((examp
 ]));
 
 // src/astro/generate.ts
-var BLUME_SRC = join26(packageRoot(), "src");
+var BLUME_SRC = join28(packageRoot(), "src");
 var canResolveFrom = (fromDir, spec) => {
   try {
-    createRequire5(pathToFileURL3(join26(fromDir, "_.js")).href).resolve(spec);
+    createRequire5(pathToFileURL3(join28(fromDir, "_.js")).href).resolve(spec);
     return true;
   } catch {
     return false;
@@ -14679,7 +15662,7 @@ var resolveReactCompiler = (config, needsReact, pkgDir = packageRoot()) => {
     return null;
   }
   try {
-    return createRequire5(pathToFileURL3(join26(pkgDir, "_.js")).href).resolve("babel-plugin-react-compiler");
+    return createRequire5(pathToFileURL3(join28(pkgDir, "_.js")).href).resolve("babel-plugin-react-compiler");
   } catch {
     return null;
   }
@@ -14689,7 +15672,7 @@ var reactCompilerWarnings = (config, needsReact, compilerPath) => needsReact &&
 ] : [];
 var resolveAstroPackageJson = (modulesDir) => {
   try {
-    return realpathSync(join26(modulesDir, "astro", "package.json"));
+    return realpathSync(join28(modulesDir, "astro", "package.json"));
   } catch {
     return null;
   }
@@ -14697,12 +15680,12 @@ var resolveAstroPackageJson = (modulesDir) => {
 var resolvedAstroHit = (fromDir) => {
   let dir = normalize3(fromDir);
   while (true) {
-    const modulesDir = join26(dir, "node_modules");
+    const modulesDir = join28(dir, "node_modules");
     const pkg = resolveAstroPackageJson(modulesDir);
     if (pkg) {
       return { modulesDir, pkg };
     }
-    const parent = dirname9(dir);
+    const parent = dirname10(dir);
     if (parent === dir) {
       return null;
     }
@@ -14717,10 +15700,10 @@ var sameRealDir = (a, b) => {
   }
 };
 var depsCandidates = (pkgDir) => [
-  join26(pkgDir, "node_modules"),
-  dirname9(pkgDir)
+  join28(pkgDir, "node_modules"),
+  dirname10(pkgDir)
 ];
-var candidateHolding = (pkgDir, ...segments) => depsCandidates(pkgDir).find((dir) => existsSync14(join26(dir, ...segments))) ?? null;
+var candidateHolding = (pkgDir, ...segments) => depsCandidates(pkgDir).find((dir) => existsSync16(join28(dir, ...segments))) ?? null;
 var linkDepsJunction = async (link, depsDir) => {
   let existing;
   try {
@@ -14733,13 +15716,13 @@ var linkDepsJunction = async (link, depsDir) => {
       return;
     }
     try {
-      if (resolve7(dirname9(link), await readlink(link)) === resolve7(depsDir)) {
+      if (resolve8(dirname10(link), await readlink(link)) === resolve8(depsDir)) {
         return;
       }
     } catch {}
     await rm2(link, { force: true });
   }
-  await mkdir6(dirname9(link), { recursive: true });
+  await mkdir6(dirname10(link), { recursive: true });
   await symlink(depsDir, link, "junction");
 };
 var readPkgVersion = (pkgJsonPath) => {
@@ -14772,7 +15755,7 @@ var dropStaleDepsLink = async (link, pkgDir) => {
   let linkedBlume;
   let runningBlume;
   try {
-    linkedBlume = await realpath(join26(link, "blume"));
+    linkedBlume = await realpath(join28(link, "blume"));
     runningBlume = await realpath(pkgDir);
   } catch {
     return;
@@ -14788,7 +15771,7 @@ var ensureDepsLink = async (outDir, pkgDir = packageRoot()) => {
   }
   const mdxDir = candidateHolding(pkgDir, "@astrojs", "mdx");
   const blumeAstro = resolveAstroPackageJson(astroDir);
-  await dropStaleDepsLink(join26(outDir, "node_modules"), pkgDir);
+  await dropStaleDepsLink(join28(outDir, "node_modules"), pkgDir);
   const outDirHit = resolvedAstroHit(outDir);
   const astroCorrect = blumeAstro !== null && outDirHit?.pkg === blumeAstro;
   const walkLandsInDeps = astroCorrect && outDirHit !== null && sameRealDir(outDirHit.modulesDir, astroDir);
@@ -14796,7 +15779,7 @@ var ensureDepsLink = async (outDir, pkgDir = packageRoot()) => {
     return null;
   }
   if (mdxDir && (mdxDir === astroDir || astroCorrect)) {
-    await linkDepsJunction(join26(outDir, "node_modules"), mdxDir);
+    await linkDepsJunction(join28(outDir, "node_modules"), mdxDir);
     return null;
   }
   return astroConflictWarning(blumeAstro, outDirHit?.pkg ?? null);
@@ -14837,14 +15820,14 @@ var searchProviderWarnings = (provider, root, pkgDir = packageRoot()) => {
   }
   return warnings;
 };
-var examplesCssFile = (root, config) => config.examples.css ? join26(root, config.examples.css) : null;
+var examplesCssFile = (root, config) => config.examples.css ? join28(root, config.examples.css) : null;
 var writeExamplesPreview = async (options) => {
   const { config, hasExamples, root, srcDir, write } = options;
   if (hasExamples) {
-    await write(join26(srcDir, "pages", ...config.basePath.split("/").filter(Boolean), "blume-examples", "[...path].astro"), examplesPageTemplate());
+    await write(join28(srcDir, "pages", ...config.basePath.split("/").filter(Boolean), "blume-examples", "[...path].astro"), examplesPageTemplate());
   }
   const cssFile = examplesCssFile(root, config);
-  return cssFile && !existsSync14(cssFile) ? [
+  return cssFile && !existsSync16(cssFile) ? [
     `examples.css points at "${config.examples.css}", which doesn't exist; previews render without it.`
   ] : [];
 };
@@ -14853,7 +15836,7 @@ var readOptional = async (path) => {
     return "";
   }
   try {
-    return await readFile14(path, "utf-8");
+    return await readFile16(path, "utf-8");
   } catch {
     return "";
   }
@@ -14873,30 +15856,30 @@ var detectUsesMath = async (root, staged = []) => {
     ignore: ["**/node_modules/**", "**/.blume/**", "**/dist/**"],
     onlyFiles: true
   });
-  const contents = await Promise.all(files.map((file) => readOptional(join26(root, file))));
+  const contents = await Promise.all(files.map((file) => readOptional(join28(root, file))));
   return [...contents, ...staged].some(containsMath);
 };
-var hashConfigSource = (source) => createHash2("sha256").update(source).digest("hex");
+var hashConfigSource = (source) => createHash3("sha256").update(source).digest("hex");
 var loadIntegrationBridge = async (config, context) => {
   if (config.integrations.length === 0 || !context.configFile) {
     return;
   }
   return {
-    configFile: relative13(context.outDir, context.configFile),
+    configFile: relative14(context.outDir, context.configFile),
     sourceHash: hashConfigSource(await readOptional(context.configFile))
   };
 };
 var writeIfChanged = async (path, content) => {
   let existing = null;
   try {
-    existing = await readFile14(path, "utf-8");
+    existing = await readFile16(path, "utf-8");
   } catch {
     existing = null;
   }
   if (existing === content) {
     return false;
   }
-  await mkdir6(dirname9(path), { recursive: true });
+  await mkdir6(dirname10(path), { recursive: true });
   const tmp = `${path}.${process.pid}.tmp`;
   await writeFile7(tmp, content, "utf-8");
   try {
@@ -14934,12 +15917,12 @@ var collectStaged = (project) => {
 var writeStagedContent = async (out, staged) => {
   const contentDir = stagedContentDir(out);
   const written = new Set;
-  await Promise.all([...staged].map(async ([entryId, text]) => {
-    const path = join26(contentDir, entryId);
+  await Promise.all([...staged].map(async ([entryId, text2]) => {
+    const path = join28(contentDir, entryId);
     written.add(normalize3(path));
-    await writeIfChanged(path, text);
+    await writeIfChanged(path, text2);
   }));
-  if (existsSync14(contentDir)) {
+  if (existsSync16(contentDir)) {
     await pruneOrphans(contentDir, written);
   }
 };
@@ -14970,9 +15953,9 @@ var readLogoSvg = (project, source) => {
   }
   const rel = source.replace(/^\//u, "");
   const file = [
-    join26(project.context.root, "public", rel),
-    join26(project.context.root, rel)
-  ].find((path) => existsSync14(path));
+    join28(project.context.root, "public", rel),
+    join28(project.context.root, rel)
+  ].find((path) => existsSync16(path));
   return file ? readFileSync9(file, "utf-8") : undefined;
 };
 var resolveLogo = (project) => {
@@ -14981,7 +15964,7 @@ var resolveLogo = (project) => {
     return null;
   }
   const config = typeof logo === "string" ? { image: logo } : logo;
-  const { href, image: source, text } = config;
+  const { href, image: source, text: text2 } = config;
   const image = typeof source === "string" ? { light: source } : source;
   const light = image?.light ?? image?.dark;
   const dark = image?.dark ?? image?.light;
@@ -14990,12 +15973,12 @@ var resolveLogo = (project) => {
   const lightSvg = readLogoSvg(project, light);
   const darkSvg = dark === light ? lightSvg : readLogoSvg(project, dark);
   if (light && light === dark && lightSvg) {
-    return { alt, href: brandHref, svg: lightSvg, text };
+    return { alt, href: brandHref, svg: lightSvg, text: text2 };
   }
   const lightDimensions = svgDimensions(lightSvg);
   const darkDimensions = svgDimensions(darkSvg);
   const dimensions = lightDimensions || darkDimensions ? { dark: darkDimensions, light: lightDimensions } : undefined;
-  return { alt, dark, dimensions, href: brandHref, light, text };
+  return { alt, dark, dimensions, href: brandHref, light, text: text2 };
 };
 var FAVICON_CANDIDATES = [
   "icon.svg",
@@ -15018,7 +16001,7 @@ var faviconType = (name) => {
 };
 var inlineDataUri = (file, type) => `data:${type};base64,${readFileSync9(file).toString("base64")}`;
 var defaultFavicon = () => ({
-  href: inlineDataUri(join26(BLUME_SRC, "assets", "icon.png"), "image/png"),
+  href: inlineDataUri(join28(BLUME_SRC, "assets", "icon.png"), "image/png"),
   type: "image/png"
 });
 var APPLE_ICON_CANDIDATES = [
@@ -15030,13 +16013,13 @@ var APPLE_ICON_CANDIDATES = [
 var resolveIconFile = (project, candidates) => {
   const { root } = project.context;
   for (const name of candidates) {
-    if (existsSync14(join26(root, "public", name))) {
+    if (existsSync16(join28(root, "public", name))) {
       return { href: `/${name}`, type: faviconType(name) };
     }
   }
   for (const name of candidates) {
-    const file = join26(root, name);
-    if (existsSync14(file)) {
+    const file = join28(root, name);
+    if (existsSync16(file)) {
       const type = faviconType(name);
       return { href: inlineDataUri(file, type ?? "image/x-icon"), type };
     }
@@ -15060,18 +16043,45 @@ var resolveBanner = (config) => {
     link: banner.link
   };
 };
+var resolveOgMark = (project, siteLogo) => {
+  const configured = project.config.seo.og.logo;
+  if (configured === false) {
+    return false;
+  }
+  if (configured) {
+    return resolveOgLogo(project, configured);
+  }
+  return siteLogo;
+};
+var resolveOgSite = (config) => {
+  const configured = config.seo.og.site;
+  if (configured === false) {
+    return;
+  }
+  if (configured !== undefined) {
+    return configured;
+  }
+  return config.deployment.site ? `${new URL(config.deployment.site).host}${normalizeBasePath(config.deployment.base)}` : undefined;
+};
+var resolveOgDescription = (config) => {
+  const configured = config.seo.og.description;
+  if (configured === false) {
+    return;
+  }
+  return configured ?? config.description;
+};
 var buildRuntimeData = (project) => {
   const { config, context, graph, manifest } = project;
   const { github } = config;
   const repoUrl = github ? `https://github.com/${github.owner}/${github.repo}` : null;
   const editBase = github ? `${repoUrl}/edit/${github.branch}` : null;
   const logo = resolveLogo(project);
-  const ogLogo = config.seo.og.logo ? resolveOgLogo(project, config.seo.og.logo) : logo?.svg;
+  const ogLogo = resolveOgMark(project, logo?.svg);
   const editUrlFor = (sourcePath) => {
     if (!(editBase && sourcePath)) {
       return null;
     }
-    const rel = relative13(context.root, sourcePath).split("\\").join("/");
+    const rel = relative14(context.root, sourcePath).split("\\").join("/");
     const editPath = github?.dir ? `${github.dir}/${rel}` : rel;
     return `${editBase}/${editPath}`;
   };
@@ -15133,10 +16143,11 @@ var buildRuntimeData = (project) => {
         route: config.ai.mcp.route
       } : null,
       og: {
+        description: resolveOgDescription(config),
         enabled: config.seo.og.enabled ?? false,
-        fonts: config.seo.og.fonts ?? [],
         logo: ogLogo,
-        palette: config.seo.og.palette
+        palette: config.seo.og.palette,
+        site: resolveOgSite(config)
       },
       repoUrl,
       search: {
@@ -15149,6 +16160,10 @@ var buildRuntimeData = (project) => {
       theme: config.theme,
       title: config.title,
       toc: config.toc,
+      webmcp: {
+        enabled: config.ai.webmcp,
+        llms: config.ai.llmsTxt.enabled
+      },
       x: config.seo.x
     },
     feeds: buildRssFeeds(project).map((feed) => ({
@@ -15182,7 +16197,7 @@ var buildRuntimeData = (project) => {
 var planMcp = (project, srcDir, userPages) => {
   const { config } = project;
   const { route } = config.ai.mcp;
-  const dir = join26(srcDir, "blume-mcp");
+  const dir = join28(srcDir, "blume-mcp");
   const base = {
     dir,
     discoveryPages: [],
@@ -15206,11 +16221,11 @@ var planMcp = (project, srcDir, userPages) => {
     ...base,
     discoveryPages: [
       {
-        entrypoint: join26(dir, "discovery.ts"),
+        entrypoint: join28(dir, "discovery.ts"),
         pattern: "/.well-known/mcp.json"
       },
       {
-        entrypoint: join26(dir, "server-card.ts"),
+        entrypoint: join28(dir, "server-card.ts"),
         pattern: "/.well-known/mcp/server-card.json"
       }
     ],
@@ -15230,11 +16245,11 @@ var writeMcpFiles = async (project, plan, write) => {
     version: data.version
   };
   await Promise.all([
-    write(join26(plan.srcDir, "generated", "mcp-data.json"), `${JSON.stringify(data)}
+    write(join28(plan.srcDir, "generated", "mcp-data.json"), `${JSON.stringify(data)}
 `),
-    write(join26(plan.srcDir, "pages", mcpPageFile(plan.route)), mcpEndpointTemplate(plan.route)),
-    write(join26(plan.dir, "discovery.ts"), staticJsonEndpointTemplate(buildMcpDiscovery(discoveryInput))),
-    write(join26(plan.dir, "server-card.ts"), staticJsonEndpointTemplate(buildMcpServerCard(discoveryInput)))
+    write(join28(plan.srcDir, "pages", mcpPageFile(plan.route)), mcpEndpointTemplate(plan.route)),
+    write(join28(plan.dir, "discovery.ts"), staticJsonEndpointTemplate(buildMcpDiscovery(discoveryInput))),
+    write(join28(plan.dir, "server-card.ts"), staticJsonEndpointTemplate(buildMcpServerCard(discoveryInput)))
   ]);
 };
 var writeAskFiles = async (project, srcDir, write) => {
@@ -15244,20 +16259,20 @@ var writeAskFiles = async (project, srcDir, write) => {
   }
   const grounded = ask.provider !== "inkeep";
   if (grounded) {
-    await write(join26(srcDir, "generated", "ask-data.json"), `${JSON.stringify(await buildAskData(project))}
+    await write(join28(srcDir, "generated", "ask-data.json"), `${JSON.stringify(await buildAskData(project))}
 `);
   }
-  await write(join26(srcDir, "pages", "api", "ask.ts"), askEndpointTemplate(resolveAskBackend(ask), grounded));
+  await write(join28(srcDir, "pages", "api", "ask.ts"), askEndpointTemplate(resolveAskBackend(ask), grounded));
 };
 var writeNotFoundPage = async (write, srcDir, pages, contentPages) => {
   if (routeIsTaken(pages, contentPages, "/404")) {
     return;
   }
-  await write(join26(srcDir, "pages", "404.astro"), notFoundPageTemplate());
+  await write(join28(srcDir, "pages", "404.astro"), notFoundPageTemplate());
 };
 var diagnosticWarning = (diagnostic) => diagnostic.suggestion ? `${diagnostic.message} ${diagnostic.suggestion}` : diagnostic.message;
 var buildComponentSlots = async (componentsFile) => {
-  const analysis = componentsFile ? analyzeComponentOverrides(await readFile14(componentsFile, "utf-8"), componentsFile) : null;
+  const analysis = componentsFile ? analyzeComponentOverrides(await readFile16(componentsFile, "utf-8"), componentsFile) : null;
   return {
     plan: planComponentSlots(componentsFile, analysis),
     tags: analysis ? [...analysis.mdx, ...analysis.islands].map((entry) => entry.key) : [],
@@ -15265,17 +16280,34 @@ var buildComponentSlots = async (componentsFile) => {
   };
 };
 var contentWatchesRuntimeDir = (hasFilesystemSource, collectionBase, context) => hasFilesystemSource && runtimeDirWithin(collectionBase, context.outDir) !== null;
+var projectOgFonts = (project) => resolveOgFonts({
+  ogFonts: project.config.seo.og.fonts,
+  themeFonts: project.config.theme.fonts,
+  themeFontsConfigured: project.themeFontsConfigured
+}, project.context.root);
+var assertFontFilesExist = (project) => {
+  const { config, context } = project;
+  const missing = missingFontFiles({ ogFonts: config.seo.og.fonts ?? [], themeFonts: config.theme.fonts }, context.root);
+  if (missing.length > 0) {
+    throw new BlumeError({
+      code: "BLUME_FONT_FILE_MISSING",
+      message: `Configured font file(s) not found: ${missing.join(", ")}. Font paths resolve relative to the project root.`,
+      severity: "error"
+    });
+  }
+};
 var generateRuntime = async (project) => {
   const { context, config } = project;
+  assertFontFilesExist(project);
   const out = context.outDir;
-  const srcDir = join26(out, "src");
-  const askPath = join26(srcDir, "generated", "Ask.astro");
-  const dataPath = join26(srcDir, "generated", "data.json");
-  const themePath = join26(srcDir, "generated", "app.css");
-  const searchClientPath = join26(srcDir, "generated", "search-client.ts");
-  const examplesPath = join26(srcDir, "generated", "examples.ts");
-  const examplesThemePath = join26(srcDir, "generated", "examples.css");
-  const openapiPath = join26(srcDir, "generated", "openapi.json");
+  const srcDir = join28(out, "src");
+  const askPath = join28(srcDir, "generated", "Ask.astro");
+  const dataPath = join28(srcDir, "generated", "data.json");
+  const themePath = join28(srcDir, "generated", "app.css");
+  const searchClientPath = join28(srcDir, "generated", "search-client.ts");
+  const examplesPath = join28(srcDir, "generated", "examples.ts");
+  const examplesThemePath = join28(srcDir, "generated", "examples.css");
+  const openapiPath = join28(srcDir, "generated", "openapi.json");
   const written = new Set;
   const write = (path, content) => {
     written.add(normalize3(path));
@@ -15330,7 +16362,7 @@ var generateRuntime = async (project) => {
   const docsCollection = resolveDocsCollection(config, context);
   const [structural] = await Promise.all([
     Promise.all([
-      write(join26(out, "astro.config.mjs"), astroConfigTemplate({
+      write(join28(out, "astro.config.mjs"), astroConfigTemplate({
         aliases: resolveTsconfigAliases(context.root),
         askPath,
         config,
@@ -15350,26 +16382,26 @@ var generateRuntime = async (project) => {
         searchClientPath,
         themePath
       })),
-      write(join26(out, "package.json"), runtimePackageTemplate(runtimeDependencies({ config, needsReact, needsSvelte, needsVue }))),
-      write(join26(out, "tsconfig.json"), runtimeTsconfigTemplate()),
-      write(join26(srcDir, "env.d.ts"), envTemplate()),
-      write(join26(srcDir, "content.config.ts"), contentConfigTemplate({
+      write(join28(out, "package.json"), runtimePackageTemplate(runtimeDependencies({ config, needsReact, needsSvelte, needsVue }))),
+      write(join28(out, "tsconfig.json"), runtimeTsconfigTemplate()),
+      write(join28(srcDir, "env.d.ts"), envTemplate()),
+      write(join28(srcDir, "content.config.ts"), contentConfigTemplate({
         collection: docsCollection,
         config,
         context,
         filesystem: hasFilesystemSource,
         staged: hasStaged
       })),
-      write(join26(srcDir, "pages", "[...slug].astro"), catchAllPageTemplate({
+      write(join28(srcDir, "pages", "[...slug].astro"), catchAllPageTemplate({
         exportEpub,
         exportPdf,
         mathEnabled: usesMath,
         needsReact
       })),
       write(askPath, askComponentTemplate(askEnabled)),
-      write(join26(srcDir, "generated", "components.ts"), slotPlan.module),
-      write(join26(srcDir, "generated", "islands.ts"), islandMapTemplate(islandDiscovery.islands)),
-      write(join26(srcDir, "generated", "examples.ts"), exampleMapTemplate(exampleDiscovery.examples, config.basePath)),
+      write(join28(srcDir, "generated", "components.ts"), slotPlan.module),
+      write(join28(srcDir, "generated", "islands.ts"), islandMapTemplate(islandDiscovery.islands)),
+      write(join28(srcDir, "generated", "examples.ts"), exampleMapTemplate(exampleDiscovery.examples, config.basePath)),
       write(examplesThemePath, examplesEntryTemplate({
         configTokens: buildThemeCss(config.theme),
         sources: [`${context.root}/**/*.{astro,jsx,svelte,ts,tsx,vue}`],
@@ -15385,17 +16417,17 @@ var generateRuntime = async (project) => {
         userTheme
       }))
     ]),
-    Promise.all(islandDiscovery.islands.map((island) => write(join26(srcDir, "generated", "islands", `${island.name}.astro`), islandWrapperTemplate(island)))),
-    Promise.all(slotPlan.wrappers.map((wrapper) => write(join26(srcDir, "generated", "component-slots", `${wrapper.name}.astro`), wrapper.content))),
-    Promise.all(exampleDiscovery.examples.map((example) => write(join26(srcDir, "generated", "examples", `${exampleSlug(example.path)}.astro`), exampleWrapperTemplate(example)))),
+    Promise.all(islandDiscovery.islands.map((island) => write(join28(srcDir, "generated", "islands", `${island.name}.astro`), islandWrapperTemplate(island)))),
+    Promise.all(slotPlan.wrappers.map((wrapper) => write(join28(srcDir, "generated", "component-slots", `${wrapper.name}.astro`), wrapper.content))),
+    Promise.all(exampleDiscovery.examples.map((example) => write(join28(srcDir, "generated", "examples", `${exampleSlug(example.path)}.astro`), exampleWrapperTemplate(example)))),
     writeAskFiles(project, srcDir, write),
     writeMcpFiles(project, mcp, write)
   ]);
   if (config.seo.og.enabled) {
-    await write(join26(srcDir, "pages", "og", "[...slug].png.ts"), ogEndpointTemplate(ogRoutes));
+    await write(join28(srcDir, "pages", "og", "[...slug].png.ts"), ogEndpointTemplate(ogRoutes, projectOgFonts(project)));
   }
   if (hasGeneratedChangelog(project, pages)) {
-    await write(join26(srcDir, "pages", "changelog.astro"), changelogIndexTemplate({
+    await write(join28(srcDir, "pages", "changelog.astro"), changelogIndexTemplate({
       exportEpub,
       exportPdf,
       needsReact,
@@ -15415,27 +16447,31 @@ var generateRuntime = async (project) => {
   ]);
   if (servesStaticIndex(config.search.provider)) {
     const documents = await buildSearchDocuments(project);
-    await write(join26(srcDir, "generated", "search.json"), `${JSON.stringify(documents)}
+    await write(join28(srcDir, "generated", "search.json"), `${JSON.stringify(documents)}
 `);
-    await write(join26(srcDir, "pages", "blume-search.json.ts"), searchEndpointTemplate());
+    await write(join28(srcDir, "pages", "blume-search.json.ts"), searchEndpointTemplate());
   }
   if (config.search.provider === "mixedbread") {
-    await write(join26(srcDir, "pages", "api", "search.ts"), mixedbreadSearchEndpointTemplate(config.search.mixedbread?.storeId ?? ""));
+    await write(join28(srcDir, "pages", "api", "search.ts"), mixedbreadSearchEndpointTemplate(config.search.mixedbread?.storeId ?? ""));
   }
   const rawMarkdown = await buildRawMarkdown(project);
+  const contentAssets = await collectContentAssets(project);
   await Promise.all([
-    write(join26(srcDir, "generated", "raw-markdown.json"), `${JSON.stringify(rawMarkdown)}
+    write(join28(srcDir, "generated", "raw-markdown.json"), `${JSON.stringify(rawMarkdown)}
+`),
+    write(join28(srcDir, "pages", "[...slug].md.ts"), rawMarkdownEndpointTemplate("md")),
+    write(join28(srcDir, "pages", "[...slug].mdx.ts"), rawMarkdownEndpointTemplate("mdx")),
+    write(join28(srcDir, "generated", "content-assets.json"), `${JSON.stringify(contentAssets)}
 `),
-    write(join26(srcDir, "pages", "[...slug].md.ts"), rawMarkdownEndpointTemplate("md")),
-    write(join26(srcDir, "pages", "[...slug].mdx.ts"), rawMarkdownEndpointTemplate("mdx"))
+    write(join28(srcDir, "pages", "blume-assets", "[...asset].ts"), contentAssetsEndpointTemplate(join28(project.context.outDir, "public", "blume-assets")))
   ]);
   const feeds = buildRssFeeds(project);
   if (feeds.length > 0) {
     const feedXml = Object.fromEntries(feeds.map((feed) => [feed.type, renderRssFeed(feed)]));
     await Promise.all([
-      write(join26(srcDir, "generated", "rss.json"), `${JSON.stringify(feedXml)}
+      write(join28(srcDir, "generated", "rss.json"), `${JSON.stringify(feedXml)}
 `),
-      write(join26(srcDir, "pages", "[section]", "rss.xml.ts"), rssEndpointTemplate())
+      write(join28(srcDir, "pages", "[section]", "rss.xml.ts"), rssEndpointTemplate())
     ]);
   }
   const warnings = [
@@ -15471,14 +16507,14 @@ var generateRuntime = async (project) => {
       root: context.root
     });
     warnings.push(...references.warnings);
-    await Promise.all(references.files.map((file) => write(join26(srcDir, "pages", file.pagePath), file.content)));
+    await Promise.all(references.files.map((file) => write(join28(srcDir, "pages", file.pagePath), file.content)));
   }
   const openApiSource2 = project.sources.find(isOpenApiSource);
   await Promise.all([
-    write(join26(srcDir, "generated", "data.json"), buildRuntimeData(project)),
+    write(join28(srcDir, "generated", "data.json"), buildRuntimeData(project)),
     write(openapiPath, `${JSON.stringify(openApiSource2 ? openApiSource2.openApiData() : {})}
 `),
-    write(join26(out, "blume.manifest.json"), `${JSON.stringify(project.manifest, null, 2)}
+    write(join28(out, "blume.manifest.json"), `${JSON.stringify(project.manifest, null, 2)}
 `),
     writeStagedContent(out, staged)
   ]);
@@ -15487,8 +16523,8 @@ var generateRuntime = async (project) => {
 };
 
 // src/cli/env.ts
-import { existsSync as existsSync15, readFileSync as readFileSync10 } from "node:fs";
-import { dirname as dirname10, join as join27, resolve as resolve8 } from "pathe";
+import { existsSync as existsSync17, readFileSync as readFileSync10 } from "node:fs";
+import { dirname as dirname11, join as join29, resolve as resolve9 } from "pathe";
 var ENV_LINE = /^\s*(?:export\s+)?(?<key>[A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?<value>.*?)\s*$/u;
 var DOUBLE_QUOTED2 = /^"(?<body>[\s\S]*)"$/u;
 var SINGLE_QUOTED = /^'(?<body>[\s\S]*)'$/u;
@@ -15534,19 +16570,19 @@ var applyEnv = (parsed) => {
 };
 var loadFile = (path) => {
   try {
-    if (existsSync15(path)) {
+    if (existsSync17(path)) {
       applyEnv(parseEnv(readFileSync10(path, "utf-8")));
     }
   } catch {}
 };
 var loadEnvFiles = (startDir) => {
-  let dir = resolve8(startDir);
+  let dir = resolve9(startDir);
   let done = false;
   while (!done) {
-    loadFile(join27(dir, ".env.local"));
-    loadFile(join27(dir, ".env"));
-    const parent = dirname10(dir);
-    done = existsSync15(join27(dir, ".git")) || parent === dir;
+    loadFile(join29(dir, ".env.local"));
+    loadFile(join29(dir, ".env"));
+    const parent = dirname11(dir);
+    done = existsSync17(join29(dir, ".git")) || parent === dir;
     dir = parent;
   }
 };
@@ -15651,20 +16687,91 @@ var emitRedirectFiles = async (config, distDir) => {
   if (redirects.length === 0 || config.deployment.output !== "static") {
     return;
   }
-  await writeFile8(join28(distDir, "blume-redirects.json"), buildRedirectManifest(redirects), "utf-8");
+  await writeFile8(join30(distDir, "blume-redirects.json"), buildRedirectManifest(redirects), "utf-8");
   const platformFiles = [
     { content: buildNetlifyRedirects(redirects), name: "_redirects" },
     { content: buildVercelConfig(redirects), name: "vercel.json" }
   ];
-  await Promise.all(platformFiles.map((file) => existsSync16(join28(distDir, file.name)) ? Promise.resolve() : writeFile8(join28(distDir, file.name), file.content, "utf-8")));
+  await Promise.all(platformFiles.map((file) => existsSync18(join30(distDir, file.name)) ? Promise.resolve() : writeFile8(join30(distDir, file.name), file.content, "utf-8")));
   logger.success(`Emitted redirect files for ${redirects.length} redirect(s)`);
 };
-var emitHeaderFiles = async (config, distDir) => {
-  if (config.deployment.output !== "static" || existsSync16(join28(distDir, "_headers"))) {
+var emitHeaderFiles = async (project, distDir) => {
+  const { config } = project;
+  if (config.deployment.output !== "static" || existsSync18(join30(distDir, "_headers"))) {
+    return;
+  }
+  await writeFile8(join30(distDir, "_headers"), buildNetlifyHeaders(config, buildHomeLinkHeader(config, project.manifest.routes.map((route) => route.path))), "utf-8");
+  logger.success("Emitted _headers (UTF-8 Content-Type + homepage Link header)");
+};
+var emitAgentSkills = async (project, distDir) => {
+  const configured = project.config.ai.skills;
+  if (!configured) {
+    return;
+  }
+  const dir = resolve10(project.context.root, configured);
+  if (!existsSync18(dir)) {
+    logger.warn(`ai.skills points at "${configured}" (${dir}), which does not exist; no skills published.`);
+    return;
+  }
+  const outDir = join30(distDir, AGENT_SKILLS_DIR.slice(1));
+  if (existsSync18(join30(outDir, "index.json"))) {
+    return;
+  }
+  const { skills, warnings } = await collectSkills(dir);
+  for (const warning of warnings) {
+    logger.warn(warning);
+  }
+  if (skills.length === 0) {
+    logger.warn(`ai.skills: no publishable skills found in "${configured}".`);
+    return;
+  }
+  await Promise.all(skills.map(async (skill) => {
+    const target = join30(outDir, skill.path);
+    await mkdir7(dirname12(target), { recursive: true });
+    await writeFile8(target, skill.content);
+  }));
+  await writeFile8(join30(outDir, "index.json"), buildSkillsIndex(skills, project.config), "utf-8");
+  logger.success(`Published ${skills.length} agent skill(s) (.well-known/agent-skills/index.json)`);
+};
+var emitWellKnownFiles = async (config, distDir) => {
+  const files = [
+    {
+      content: buildSignaturesDirectory(config),
+      label: "Web Bot Auth",
+      path: SIGNATURES_DIRECTORY_PATH
+    },
+    {
+      content: buildApiCatalog(config),
+      label: "RFC 9727",
+      path: API_CATALOG_PATH
+    }
+  ];
+  for (const file of files) {
+    const target = join30(distDir, file.path.slice(1));
+    if (!file.content || existsSync18(target)) {
+      continue;
+    }
+    await mkdir7(join30(distDir, ".well-known"), { recursive: true });
+    await writeFile8(target, file.content, "utf-8");
+    logger.success(`Generated ${file.path.slice(1)} (${file.label})`);
+  }
+};
+var emitVercelNegotiation = async (config, routePaths, root) => {
+  const configPath = join30(root, ".vercel", "output", "config.json");
+  if (!existsSync18(configPath)) {
+    return;
+  }
+  const overrides = {
+    ...hasApiCatalog(config) ? { [API_CATALOG_PATH.slice(1)]: API_CATALOG_TYPE } : {},
+    ...config.ai.webBotAuth.keys.length > 0 ? { [SIGNATURES_DIRECTORY_PATH.slice(1)]: SIGNATURES_DIRECTORY_TYPE } : {}
+  };
+  const injected = injectNegotiationRoutes(await readFile17(configPath, "utf-8"), routePaths, buildHomeLinkHeader(config, routePaths), overrides);
+  if (injected === null) {
+    logger.warn("Could not wire Accept: text/markdown negotiation into .vercel/output/config.json — raw Markdown stays available at the .md URLs.");
     return;
   }
-  await writeFile8(join28(distDir, "_headers"), buildNetlifyHeaders(config), "utf-8");
-  logger.success("Emitted _headers (UTF-8 Content-Type for raw endpoints)");
+  await writeFile8(configPath, injected, "utf-8");
+  logger.success("Wired Accept: text/markdown negotiation into the Vercel routing config");
 };
 var formatBytes2 = (bytes) => {
   if (bytes < 1024) {
@@ -15674,14 +16781,14 @@ var formatBytes2 = (bytes) => {
   return `${(bytes / 1024).toFixed(digits)} kB`;
 };
 var astroAssets = async (distDir, ext) => {
-  const astroDir = join28(distDir, "_astro");
-  if (!existsSync16(astroDir)) {
+  const astroDir = join30(distDir, "_astro");
+  if (!existsSync18(astroDir)) {
     return [];
   }
-  const entries = await readdir(astroDir);
+  const entries = await readdir2(astroDir);
   const files = entries.filter((name) => name.endsWith(`.${ext}`));
   const sized = await Promise.all(files.map(async (name) => {
-    const info = await stat2(join28(astroDir, name));
+    const info = await stat3(join30(astroDir, name));
     return { name, size: info.size };
   }));
   return sized.toSorted((a, b) => b.size - a.size);
@@ -15734,26 +16841,26 @@ var runClientAssetChecks = async (staticDir, args) => {
 var isolatedOutputDir = (config, context) => {
   const { adapter, output } = config.deployment;
   if (output === "server" && adapter === "vercel") {
-    return join28(context.outDir, ".vercel", "output");
+    return join30(context.outDir, ".vercel", "output");
   }
-  return context.distDir ?? join28(context.outDir, "dist");
+  return context.distDir ?? join30(context.outDir, "dist");
 };
 var isolatedStaticDir = (config, context) => {
   const { adapter, output } = config.deployment;
   const outputDir = isolatedOutputDir(config, context);
   if (output === "server" && adapter === "vercel") {
-    return join28(outputDir, "static");
+    return join30(outputDir, "static");
   }
   if (output === "server" && adapter === "node") {
-    return join28(outputDir, "client");
+    return join30(outputDir, "client");
   }
   return outputDir;
 };
 var publishLlmsFiles = async (project, distDir) => {
-  const indexPath = join28(distDir, "llms.txt");
-  const fullPath = join28(distDir, "llms-full.txt");
-  const writeIndex = !existsSync16(indexPath);
-  const writeFull = !existsSync16(fullPath);
+  const indexPath = join30(distDir, "llms.txt");
+  const fullPath = join30(distDir, "llms-full.txt");
+  const writeIndex = !existsSync18(indexPath);
+  const writeFull = !existsSync18(fullPath);
   if (!(writeIndex || writeFull)) {
     return;
   }
@@ -15786,23 +16893,25 @@ var publishBuildArtifacts = async (project, distDir, args) => {
     await publishLlmsFiles(project, distDir);
   }
   const sitemap = buildSitemap(project);
-  if (sitemap && !existsSync16(join28(distDir, "sitemap.xml"))) {
-    await writeFile8(join28(distDir, "sitemap.xml"), sitemap, "utf-8");
+  if (sitemap && !existsSync18(join30(distDir, "sitemap.xml"))) {
+    await writeFile8(join30(distDir, "sitemap.xml"), sitemap, "utf-8");
     logger.success("Generated sitemap.xml");
   }
   const robots = buildRobots(project);
-  if (robots && !existsSync16(join28(distDir, "robots.txt"))) {
-    await writeFile8(join28(distDir, "robots.txt"), robots, "utf-8");
+  if (robots && !existsSync18(join30(distDir, "robots.txt"))) {
+    await writeFile8(join30(distDir, "robots.txt"), robots, "utf-8");
     logger.success("Generated robots.txt");
   }
   const agentReadability = buildAgentReadability(project);
-  if (agentReadability && !existsSync16(join28(distDir, "agent-readability.json"))) {
-    await writeFile8(join28(distDir, "agent-readability.json"), `${JSON.stringify(agentReadability, null, 2)}
+  if (agentReadability && !existsSync18(join30(distDir, "agent-readability.json"))) {
+    await writeFile8(join30(distDir, "agent-readability.json"), `${JSON.stringify(agentReadability, null, 2)}
 `, "utf-8");
     logger.success("Generated agent-readability.json");
   }
+  await emitWellKnownFiles(project.config, distDir);
+  await emitAgentSkills(project, distDir);
   await emitRedirectFiles(project.config, distDir);
-  await emitHeaderFiles(project.config, distDir);
+  await emitHeaderFiles(project, distDir);
   const { config } = project;
   const features = serverFeatures(config);
   const sitemapNote = config.seo.sitemap ? "no (set deployment.site)" : "no (seo.sitemap is false)";
@@ -15916,16 +17025,19 @@ var buildCommand = defineCommand3({
     if (surfaced.moved) {
       logger.success(`Surfaced ${adapter} output to ${surfaced.to}`);
     }
+    if (project.config.deployment.output === "server" && adapter === "vercel") {
+      await emitVercelNegotiation(project.config, project.manifest.routes.map((route) => route.path), root);
+    }
     await publishBuildArtifacts(project, deployStaticDir(project.config, project.context), args);
   }
 });
 
 // src/cli/commands/check.ts
-import { existsSync as existsSync17 } from "node:fs";
+import { existsSync as existsSync19 } from "node:fs";
 import { check } from "@astrojs/check";
 import { sync } from "astro";
 import { defineCommand as defineCommand4 } from "citty";
-import { join as join29 } from "pathe";
+import { join as join31 } from "pathe";
 var checkCommand = defineCommand4({
   args: {
     isolated: {
@@ -15961,13 +17073,13 @@ var checkCommand = defineCommand4({
     });
     const { outDir } = project.context;
     await sync({ logLevel: "warn", root: outDir });
-    const tsconfig = join29(root, "tsconfig.json");
+    const tsconfig = join31(root, "tsconfig.json");
     logger.start(`Type-checking ${project.graph.pages.length} page(s)`);
     const failed = await check({
       minimumFailingSeverity: "error",
       minimumSeverity: "hint",
       root: outDir,
-      tsconfig: existsSync17(tsconfig) ? tsconfig : undefined,
+      tsconfig: existsSync19(tsconfig) ? tsconfig : undefined,
       watch: false
     });
     if (failed) {
@@ -15982,7 +17094,7 @@ var checkCommand = defineCommand4({
 import { watch } from "node:fs";
 import { dev } from "astro";
 import { defineCommand as defineCommand5 } from "citty";
-import { basename as basename4, dirname as dirname11 } from "pathe";
+import { basename as basename4, dirname as dirname13 } from "pathe";
 
 // src/astro/integration.ts
 var overlayServer = null;
@@ -16175,7 +17287,7 @@ var devCommand = defineCommand5({
       }),
       ...fileTargets.map((target) => {
         const name = basename4(target);
-        const watcher = watch(dirname11(target), (_event, filename) => {
+        const watcher = watch(dirname13(target), (_event, filename) => {
           if (!filename || filename === name) {
             regenerate();
           }
@@ -16199,12 +17311,12 @@ var devCommand = defineCommand5({
 // src/cli/commands/doctor.ts
 import { readFileSync as readFileSync11 } from "node:fs";
 import { defineCommand as defineCommand6 } from "citty";
-import { join as join30 } from "pathe";
+import { join as join32 } from "pathe";
 var FALLBACK_MIN_NODE = "22.12.0";
 var LEADING_RANGE = /^[^\d]*/u;
 var minSupportedNode = () => {
   try {
-    const pkg = JSON.parse(readFileSync11(join30(packageRoot(), "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync11(join32(packageRoot(), "package.json"), "utf-8"));
     const range = pkg.engines?.node ?? "";
     return range.replace(LEADING_RANGE, "") || FALLBACK_MIN_NODE;
   } catch {
@@ -16297,21 +17409,21 @@ var doctorCommand = defineCommand6({
 
 // src/cli/commands/eject.ts
 import { defineCommand as defineCommand7 } from "citty";
-import { relative as relative16 } from "pathe";
+import { relative as relative17 } from "pathe";
 
 // src/registry/eject.ts
-import { existsSync as existsSync18 } from "node:fs";
-import { cp as cp2, mkdir as mkdir7, readFile as readFile15, rm as rm3, writeFile as writeFile9 } from "node:fs/promises";
-import { join as join31, relative as relative14 } from "pathe";
+import { existsSync as existsSync20 } from "node:fs";
+import { cp as cp2, mkdir as mkdir8, readFile as readFile18, rm as rm3, writeFile as writeFile9 } from "node:fs/promises";
+import { join as join33, relative as relative15 } from "pathe";
 var toPosix = (path) => path.split("\\").join("/");
 var LOCAL_BLUME_SOURCE = "../../node_modules/blume/src/**/*.{astro,ts,tsx}";
 var blumeSourceGlob = (root, genDir, resolveBlumeRoot = packageRoot) => {
-  if (existsSync18(join31(root, "node_modules", "blume"))) {
+  if (existsSync20(join33(root, "node_modules", "blume"))) {
     return LOCAL_BLUME_SOURCE;
   }
   try {
-    const src = join31(resolveBlumeRoot(), "src");
-    return `${toPosix(relative14(genDir, src))}/**/*.{astro,ts,tsx}`;
+    const src = join33(resolveBlumeRoot(), "src");
+    return `${toPosix(relative15(genDir, src))}/**/*.{astro,ts,tsx}`;
   } catch {
     console.warn('blume: could not locate the installed blume package; src/generated/app.css keeps its default `@source "../../node_modules/blume/..."` glob. If blume is hoisted elsewhere, point that glob at its install location or Blume\'s utility classes will be missing.');
     return LOCAL_BLUME_SOURCE;
@@ -16324,28 +17436,28 @@ var ejectOpenApiData = (project) => {
 var askFiles = async (project, srcDir, genDir) => {
   const { ask } = project.config.ai;
   if (!(ask?.enabled && !ask.endpoint)) {
-    const endpointPath = join31(srcDir, "pages", "api", "ask.ts");
-    if (existsSync18(endpointPath)) {
-      const content = await readFile15(endpointPath, "utf-8");
+    const endpointPath = join33(srcDir, "pages", "api", "ask.ts");
+    if (existsSync20(endpointPath)) {
+      const content = await readFile18(endpointPath, "utf-8");
       if (content.startsWith("// Generated by Blume. Do not edit.")) {
         await rm3(endpointPath, { force: true });
       }
     }
-    await rm3(join31(genDir, "ask-data.json"), { force: true });
+    await rm3(join33(genDir, "ask-data.json"), { force: true });
     return [];
   }
   const grounded = ask.provider !== "inkeep";
   const files = [
     {
       content: askEndpointTemplate(resolveAskBackend(ask), grounded),
-      path: join31(srcDir, "pages", "api", "ask.ts")
+      path: join33(srcDir, "pages", "api", "ask.ts")
     }
   ];
   if (grounded) {
     files.push({
       content: `${JSON.stringify(await buildAskData(project))}
 `,
-      path: join31(genDir, "ask-data.json")
+      path: join33(genDir, "ask-data.json")
     });
   }
   return files;
@@ -16378,19 +17490,19 @@ var mcpFiles = async (project, userPages, srcDir, genDir) => {
     {
       content: `${JSON.stringify(data)}
 `,
-      path: join31(genDir, "mcp-data.json")
+      path: join33(genDir, "mcp-data.json")
     },
     {
       content: mcpEndpointTemplate(route),
-      path: join31(srcDir, "pages", mcpPageFile(route))
+      path: join33(srcDir, "pages", mcpPageFile(route))
     },
     {
       content: staticJsonEndpointTemplate(buildMcpDiscovery(discoveryInput)),
-      path: join31(srcDir, "blume-mcp", "discovery.ts")
+      path: join33(srcDir, "blume-mcp", "discovery.ts")
     },
     {
       content: staticJsonEndpointTemplate(buildMcpServerCard(discoveryInput)),
-      path: join31(srcDir, "blume-mcp", "server-card.ts")
+      path: join33(srcDir, "blume-mcp", "server-card.ts")
     }
   ];
 };
@@ -16403,23 +17515,23 @@ var changelogFiles = (project, userPages, srcDir, options) => {
   return [
     {
       content: changelogIndexTemplate(options),
-      path: join31(srcDir, "pages", "changelog.astro")
+      path: join33(srcDir, "pages", "changelog.astro")
     }
   ];
 };
-var readExamplesCss = (root, css) => css && existsSync18(join31(root, css)) ? readFile15(join31(root, css), "utf-8") : Promise.resolve("");
+var readExamplesCss = (root, css) => css && existsSync20(join33(root, css)) ? readFile18(join33(root, css), "utf-8") : Promise.resolve("");
 var examplesPreviewFiles = (srcDir, basePath, hasExamples) => hasExamples ? [
   {
     content: examplesPageTemplate(),
-    path: join31(srcDir, "pages", ...basePath.split("/").filter(Boolean), "blume-examples", "[...path].astro")
+    path: join33(srcDir, "pages", ...basePath.split("/").filter(Boolean), "blume-examples", "[...path].astro")
   }
 ] : [];
-var ejectIntegrationBridge = (config, root, configFile) => config.integrations.length > 0 && configFile ? { configFile: toPosix(relative14(root, configFile)) } : undefined;
+var ejectIntegrationBridge = (config, root, configFile) => config.integrations.length > 0 && configFile ? { configFile: toPosix(relative15(root, configFile)) } : undefined;
 var eject = async (root) => {
   const project = await scanProject(root, { mode: "build" });
   const { context, config } = project;
-  const srcDir = join31(root, "src");
-  const genDir = join31(srcDir, "generated");
+  const srcDir = join33(root, "src");
+  const genDir = join33(srcDir, "generated");
   const askEnabled = config.ai.ask?.enabled ?? false;
   const exportPdf = config.export.pdf;
   const exportEpub = config.export.epub;
@@ -16437,7 +17549,7 @@ var eject = async (root) => {
     context.pagesRoot ? discoverPages(context.pagesRoot) : Promise.resolve([]),
     detectNeedsReact(root),
     detectUsesMath(root),
-    context.themeFile ? readFile15(context.themeFile, "utf-8") : Promise.resolve(""),
+    context.themeFile ? readFile18(context.themeFile, "utf-8") : Promise.resolve(""),
     readExamplesCss(root, config.examples.css),
     buildRawMarkdown(project),
     discoverIslands(root)
@@ -16451,14 +17563,14 @@ var eject = async (root) => {
   const needsSvelte = frameworks.has("svelte");
   const relContext = {
     ...context,
-    contentRoot: toPosix(relative14(root, context.contentRoot)),
+    contentRoot: toPosix(relative15(root, context.contentRoot)),
     outDir: ".",
     root: "."
   };
-  const componentsImport = context.componentsFile ? `../../${toPosix(relative14(root, context.componentsFile))}` : null;
+  const componentsImport = context.componentsFile ? `../../${toPosix(relative15(root, context.componentsFile))}` : null;
   const relPages = [
     ...pages.map((page) => ({
-      entrypoint: toPosix(relative14(root, page.entrypoint)),
+      entrypoint: toPosix(relative15(root, page.entrypoint)),
       pattern: page.pattern
     })),
     ...mcpDiscoveryPages(project, pages)
@@ -16485,14 +17597,14 @@ var eject = async (root) => {
         searchClientPath: "./src/generated/search-client.ts",
         themePath: "./src/generated/app.css"
       }),
-      path: join31(root, "astro.config.mjs")
+      path: join33(root, "astro.config.mjs")
     },
     {
       content: runtimeTsconfigTemplate(),
-      path: join31(root, "tsconfig.json"),
+      path: join33(root, "tsconfig.json"),
       skipIfExists: true
     },
-    { content: envTemplate(), path: join31(srcDir, "env.d.ts") },
+    { content: envTemplate(), path: join33(srcDir, "env.d.ts") },
     {
       content: contentConfigTemplate({
         config,
@@ -16500,7 +17612,7 @@ var eject = async (root) => {
         staged: hasStaged,
         stagedBase: stagedDir
       }),
-      path: join31(srcDir, "content.config.ts")
+      path: join33(srcDir, "content.config.ts")
     },
     {
       content: catchAllPageTemplate({
@@ -16509,19 +17621,19 @@ var eject = async (root) => {
         mathEnabled: usesMath,
         needsReact
       }),
-      path: join31(srcDir, "pages", "[...slug].astro")
+      path: join33(srcDir, "pages", "[...slug].astro")
     },
     {
       content: planComponentSlots(componentsImport, null).module,
-      path: join31(genDir, "components.ts")
+      path: join33(genDir, "components.ts")
     },
     {
       content: islandMapTemplate(islands.islands),
-      path: join31(genDir, "islands.ts")
+      path: join33(genDir, "islands.ts")
     },
     {
       content: exampleMapTemplate(examples.examples, config.basePath),
-      path: join31(genDir, "examples.ts")
+      path: join33(genDir, "examples.ts")
     },
     {
       content: examplesEntryTemplate({
@@ -16529,7 +17641,7 @@ var eject = async (root) => {
         sources: ["../../**/*.{astro,jsx,svelte,ts,tsx,vue}"],
         userCss: userExamplesCss
       }),
-      path: join31(genDir, "examples.css")
+      path: join33(genDir, "examples.css")
     },
     {
       content: tailwindEntryTemplate({
@@ -16541,30 +17653,30 @@ var eject = async (root) => {
         twoslashCss: twoslashCss(),
         userTheme
       }),
-      path: join31(genDir, "app.css")
+      path: join33(genDir, "app.css")
     },
-    { content: buildRuntimeData(project), path: join31(genDir, "data.json") },
+    { content: buildRuntimeData(project), path: join33(genDir, "data.json") },
     {
       content: askComponentTemplate(askEnabled),
-      path: join31(genDir, "Ask.astro")
+      path: join33(genDir, "Ask.astro")
     },
     {
       content: `${JSON.stringify(ejectOpenApiData(project))}
 `,
-      path: join31(genDir, "openapi.json")
+      path: join33(genDir, "openapi.json")
     },
     {
       content: `${JSON.stringify(rawMarkdown)}
 `,
-      path: join31(genDir, "raw-markdown.json")
+      path: join33(genDir, "raw-markdown.json")
     },
     {
       content: rawMarkdownEndpointTemplate("md"),
-      path: join31(srcDir, "pages", "[...slug].md.ts")
+      path: join33(srcDir, "pages", "[...slug].md.ts")
     },
     {
       content: rawMarkdownEndpointTemplate("mdx"),
-      path: join31(srcDir, "pages", "[...slug].mdx.ts")
+      path: join33(srcDir, "pages", "[...slug].mdx.ts")
     }
   ];
   if (askEnabled) {
@@ -16573,7 +17685,7 @@ var eject = async (root) => {
   if (config.seo.og.enabled) {
     files.push({
       content: ogEndpointTemplate(customOgRoutes(pages, config.title, config.seo.og.titles)),
-      path: join31(srcDir, "pages", "og", "[...slug].png.ts")
+      path: join33(srcDir, "pages", "og", "[...slug].png.ts")
     });
   }
   files.push(...await mcpFiles(project, pages, srcDir, genDir), ...changelogFiles(project, pages, srcDir, {
@@ -16585,28 +17697,28 @@ var eject = async (root) => {
   if (!routeIsTaken(pages, project.graph.pages, "/404")) {
     files.push({
       content: notFoundPageTemplate(),
-      path: join31(srcDir, "pages", "404.astro")
+      path: join33(srcDir, "pages", "404.astro")
     });
   }
   files.push({
     content: searchClientTemplate(config),
-    path: join31(genDir, "search-client.ts")
+    path: join33(genDir, "search-client.ts")
   });
   if (servesStaticIndex(config.search.provider)) {
     const documents = await buildSearchDocuments(project);
     files.push({
       content: `${JSON.stringify(documents)}
 `,
-      path: join31(genDir, "search.json")
+      path: join33(genDir, "search.json")
     }, {
       content: searchEndpointTemplate(),
-      path: join31(srcDir, "pages", "blume-search.json.ts")
+      path: join33(srcDir, "pages", "blume-search.json.ts")
     });
   }
   if (config.search.provider === "mixedbread") {
     files.push({
       content: mixedbreadSearchEndpointTemplate(config.search.mixedbread?.storeId ?? ""),
-      path: join31(srcDir, "pages", "api", "search.ts")
+      path: join33(srcDir, "pages", "api", "search.ts")
     });
   }
   const feeds = buildRssFeeds(project);
@@ -16615,10 +17727,10 @@ var eject = async (root) => {
     files.push({
       content: `${JSON.stringify(feedXml)}
 `,
-      path: join31(genDir, "rss.json")
+      path: join33(genDir, "rss.json")
     }, {
       content: rssEndpointTemplate(),
-      path: join31(srcDir, "pages", "[section]", "rss.xml.ts")
+      path: join33(srcDir, "pages", "[section]", "rss.xml.ts")
     });
   }
   const warnings = [];
@@ -16632,28 +17744,28 @@ var eject = async (root) => {
     for (const file of references.files) {
       files.push({
         content: file.content,
-        path: join31(srcDir, "pages", file.pagePath)
+        path: join33(srcDir, "pages", file.pagePath)
       });
     }
   }
   files.push(...islands.islands.map((island) => ({
     content: islandWrapperTemplate(island),
-    path: join31(genDir, "islands", `${island.name}.astro`)
+    path: join33(genDir, "islands", `${island.name}.astro`)
   })), ...examples.examples.map((example) => ({
     content: exampleWrapperTemplate(example),
-    path: join31(genDir, "examples", `${exampleSlug(example.path)}.astro`)
+    path: join33(genDir, "examples", `${exampleSlug(example.path)}.astro`)
   })), ...examplesPreviewFiles(srcDir, config.basePath, examples.examples.length > 0));
   for (const [entryId, content] of staged) {
-    files.push({ content, path: join31(root, stagedDir, entryId) });
+    files.push({ content, path: join33(root, stagedDir, entryId) });
   }
-  const written = files.filter((file) => !(file.skipIfExists && existsSync18(file.path)));
+  const written = files.filter((file) => !(file.skipIfExists && existsSync20(file.path)));
   await Promise.all(written.map(async (file) => {
-    await mkdir7(join31(file.path, ".."), { recursive: true });
+    await mkdir8(join33(file.path, ".."), { recursive: true });
     await writeFile9(file.path, file.content, "utf-8");
   }));
-  const assetsSrc = join31(context.outDir, "public", "blume-assets");
-  if (existsSync18(assetsSrc)) {
-    await cp2(assetsSrc, join31(root, "public", "blume-assets"), {
+  const assetsSrc = join33(context.outDir, "public", "blume-assets");
+  if (existsSync20(assetsSrc)) {
+    await cp2(assetsSrc, join33(root, "public", "blume-assets"), {
       recursive: true
     });
   }
@@ -16662,8 +17774,8 @@ var eject = async (root) => {
 };
 
 // src/cli/eject-scripts.ts
-import { readFile as readFile16, writeFile as writeFile10 } from "node:fs/promises";
-import { join as join32 } from "pathe";
+import { readFile as readFile19, writeFile as writeFile10 } from "node:fs/promises";
+import { join as join34 } from "pathe";
 var droppedArtifactNotices = (config) => {
   const notices = [];
   if (config.search.provider === "pagefind") {
@@ -16690,10 +17802,10 @@ var droppedArtifactNotices = (config) => {
   return notices;
 };
 var updatePackageScripts = async (root) => {
-  const pkgPath = join32(root, "package.json");
+  const pkgPath = join34(root, "package.json");
   let pkg;
   try {
-    pkg = JSON.parse(await readFile16(pkgPath, "utf-8"));
+    pkg = JSON.parse(await readFile19(pkgPath, "utf-8"));
   } catch {
     return;
   }
@@ -16709,9 +17821,9 @@ var updatePackageScripts = async (root) => {
 };
 
 // src/cli/init/scaffold.ts
-import { existsSync as existsSync19 } from "node:fs";
-import { mkdir as mkdir8, writeFile as writeFile11 } from "node:fs/promises";
-import { basename as basename5, dirname as dirname12, isAbsolute as isAbsolute9, join as join33, relative as relative15 } from "pathe";
+import { existsSync as existsSync21 } from "node:fs";
+import { mkdir as mkdir9, writeFile as writeFile11 } from "node:fs/promises";
+import { basename as basename5, dirname as dirname14, isAbsolute as isAbsolute10, join as join35, relative as relative16 } from "pathe";
 
 // src/core/package-json.ts
 var toPackageName = (raw) => raw.toLowerCase().replaceAll(/[^a-z0-9._-]+/gu, "-").replaceAll(/^[-_.]+|[-_.]+$/gu, "") || "docs";
@@ -16770,7 +17882,7 @@ var STARTERS = {
     files: (dir) => [
       {
         content: page("API Reference", "Explore the API.", "# API Reference\n\nYour OpenAPI spec renders at [`/api`](/api). Point `openapi.sources` at your own spec in `blume.config.ts`."),
-        path: join33(dir, "index.mdx")
+        path: join35(dir, "index.mdx")
       }
     ]
   },
@@ -16785,7 +17897,7 @@ var STARTERS = {
     files: (dir) => [
       {
         content: page("Introduction", "Welcome to your new Blume docs.", "# Introduction\n\nWrite your docs here, and log releases under `changelog/`."),
-        path: join33(dir, "index.mdx")
+        path: join35(dir, "index.mdx")
       },
       {
         content: `---
@@ -16796,7 +17908,7 @@ date: 2026-01-01
 
 The first release. Edit \`${dir}/changelog/v1-0-0.mdx\` or add new entries beside it.
 `,
-        path: join33(dir, "changelog", "v1-0-0.mdx")
+        path: join35(dir, "changelog", "v1-0-0.mdx")
       }
     ]
   },
@@ -16809,7 +17921,7 @@ The first release. Edit \`${dir}/changelog/v1-0-0.mdx\` or add new entries besid
 Welcome to **Blume** — markdown-first docs powered by Astro and Vite.
 
 Edit \`${dir}/index.mdx\` to get started, then run \`blume dev\`.`),
-        path: join33(dir, "index.mdx")
+        path: join35(dir, "index.mdx")
       }
     ]
   },
@@ -16820,11 +17932,11 @@ Edit \`${dir}/index.mdx\` to get started, then run \`blume dev\`.`),
         content: page("Introduction", "Get started with the SDK.", `# Introduction
 
 Install the SDK and make your first call. See [Installation](/installation).`),
-        path: join33(dir, "index.mdx")
+        path: join35(dir, "index.mdx")
       },
       {
         content: page("Installation", "Install the SDK.", "# Installation\n\n```package-install\nyour-sdk\n```"),
-        path: join33(dir, "installation.mdx")
+        path: join35(dir, "installation.mdx")
       }
     ]
   }
@@ -16839,7 +17951,7 @@ var detectPackageManager = (userAgent) => {
   const name = userAgent?.split("/")[0];
   return name !== undefined && PACKAGE_MANAGERS.includes(name) ? name : "npm";
 };
-var validateContentDir = (root, dir) => isAbsolute9(dir) || relative15(root, join33(root, dir)).startsWith("..") ? "Must be a relative path inside the project." : undefined;
+var validateContentDir = (root, dir) => isAbsolute10(dir) || relative16(root, join35(root, dir)).startsWith("..") ? "Must be a relative path inside the project." : undefined;
 var titleize = (raw) => {
   const words = raw.replaceAll(/[-_.]+/gu, " ").split(/\s+/u).filter(Boolean);
   return words.length === 0 ? "My Docs" : words.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
@@ -16916,27 +18028,27 @@ export default defineConfig({
 `;
 var extraDepsFor = (sources) => ({
   ...sources.includes("notion") && { "@notionhq/client": "^2.2.15" },
-  ...sources.includes("sanity") && { "@sanity/client": "^6.21.0" }
+  ...sources.includes("sanity") && { "@sanity/client": "^7.25.0" }
 });
 var buildPlan = (root, answers) => {
   const files = [
     {
       content: blumePackageJson(toPackageName(basename5(root)), extraDepsFor(answers.sources)),
-      path: join33(root, "package.json")
+      path: join35(root, "package.json")
     },
-    { content: buildConfig(answers), path: join33(root, "blume.config.ts") }
+    { content: buildConfig(answers), path: join35(root, "blume.config.ts") }
   ];
   if (answers.sources.length === 0 || answers.sources.includes("filesystem")) {
-    files.push(...STARTERS[answers.template].files(answers.contentDir).map((file) => ({ ...file, path: join33(root, file.path) })));
+    files.push(...STARTERS[answers.template].files(answers.contentDir).map((file) => ({ ...file, path: join35(root, file.path) })));
   }
   return files;
 };
 var writeFileSafe = async (file, log) => {
-  if (existsSync19(file.path)) {
+  if (existsSync21(file.path)) {
     log.info(`Skipped existing ${file.path}`);
     return false;
   }
-  await mkdir8(dirname12(file.path), { recursive: true });
+  await mkdir9(dirname14(file.path), { recursive: true });
   await writeFile11(file.path, file.content, "utf-8");
   log.success(`Created ${file.path}`);
   return true;
@@ -17012,7 +18124,7 @@ var ejectCommand = defineCommand7({
     }
     logger.success(`Ejected ${files.length} file(s):`);
     for (const file of files) {
-      process.stdout.write(`  ${relative16(root, file)}
+      process.stdout.write(`  ${relative17(root, file)}
 `);
     }
     reportDroppedArtifacts(notices);
@@ -17028,9 +18140,9 @@ The blume package remains importable.`);
 });
 
 // src/cli/commands/eval.ts
-import { existsSync as existsSync20 } from "node:fs";
+import { existsSync as existsSync22 } from "node:fs";
 import { defineCommand as defineCommand8 } from "citty";
-import { join as join37 } from "pathe";
+import { join as join39 } from "pathe";
 
 // src/eval/prompts.ts
 var readerPrompt = (question) => `You are evaluating whether a product's documentation can answer a user's question.
@@ -17099,7 +18211,7 @@ When you are done, print the file and suggest running \`blume eval\` to try it.`
 // src/eval/report.ts
 import { mkdtemp as mkdtemp2, writeFile as writeFile12 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join34, relative as relative17 } from "pathe";
+import { join as join36, relative as relative18 } from "pathe";
 var ESC4 = String.fromCodePoint(27);
 var COLORS3 = {
   bold: `${ESC4}[1m`,
@@ -17180,15 +18292,15 @@ var summaryLine2 = (result) => {
 var headerLine = (total, agent) => `${COLORS3.bold}blume eval${COLORS3.reset}  ${total} question(s) · ${AGENTS[agent].name}`;
 var startLine = (id2, index, total) => `  ${COLORS3.dim}▸ ${id2} (${index + 1}/${total})${COLORS3.reset}`;
 var fixLines = (result, root) => result.diagnostics.filter((diagnostic) => diagnostic.code !== "BLUME_EVAL_ROUTE_UNKNOWN").map((finding2) => {
-  const site = finding2.file ? `${relative17(root, finding2.file)}${finding2.line ? `:${finding2.line}` : ""}` : "";
+  const site = finding2.file ? `${relative18(root, finding2.file)}${finding2.line ? `:${finding2.line}` : ""}` : "";
   return `  ${COLORS3.cyan}fix:${COLORS3.reset} ${site} ${COLORS3.dim}${finding2.message}${COLORS3.reset}`;
 });
 var warningLines = (result, root) => result.diagnostics.filter((diagnostic) => diagnostic.code === "BLUME_EVAL_ROUTE_UNKNOWN").map((finding2) => {
-  const site = finding2.file ? ` ${relative17(root, finding2.file)}${finding2.line ? `:${finding2.line}` : ""}` : "";
+  const site = finding2.file ? ` ${relative18(root, finding2.file)}${finding2.line ? `:${finding2.line}` : ""}` : "";
   return `  ${COLORS3.yellow}⚠${COLORS3.reset}${site} ${COLORS3.dim}${finding2.message}${COLORS3.reset}`;
 });
 var evalReportJson = (result, root, threshold) => {
-  const diagnostics = result.diagnostics.map((diagnostic) => diagnostic.file ? { ...diagnostic, file: relative17(root, diagnostic.file) } : diagnostic);
+  const diagnostics = result.diagnostics.map((diagnostic) => diagnostic.file ? { ...diagnostic, file: relative18(root, diagnostic.file) } : diagnostic);
   return `${JSON.stringify({
     diagnostics,
     eval: {
@@ -17204,21 +18316,21 @@ var evalReportJson = (result, root, threshold) => {
 `;
 };
 var writeEvalReport = async (result, root, threshold) => {
-  const dir = await mkdtemp2(join34(tmpdir2(), "blume-eval-"));
-  const path = join34(dir, "report.json");
+  const dir = await mkdtemp2(join36(tmpdir2(), "blume-eval-"));
+  const path = join36(dir, "report.json");
   await writeFile12(path, evalReportJson(result, root, threshold));
   return path;
 };
 
 // src/eval/run.ts
-import { mkdir as mkdir9, mkdtemp as mkdtemp3, writeFile as writeFile14 } from "node:fs/promises";
+import { mkdir as mkdir10, mkdtemp as mkdtemp3, writeFile as writeFile14 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join36 } from "pathe";
+import { join as join38 } from "pathe";
 
 // src/eval/agents.ts
 import { spawn as spawn2 } from "node:child_process";
-import { readFile as readFile17, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join35 } from "pathe";
+import { readFile as readFile20, writeFile as writeFile13 } from "node:fs/promises";
+import { join as join37 } from "pathe";
 import { z as z3 } from "zod";
 var KILL_GRACE_MS = 5000;
 var MCP_TOOL_NAMES = [
@@ -17240,7 +18352,7 @@ var DISALLOWED_TOOLS = [
   "WebSearch",
   "Task"
 ];
-var runAgentHeadless = (bin, args, options) => new Promise((resolve9, reject) => {
+var runAgentHeadless = (bin, args, options) => new Promise((resolve11, reject) => {
   const platform = options.platform ?? process.platform;
   const child = spawn2(bin, args, {
     cwd: options.cwd,
@@ -17269,12 +18381,12 @@ var runAgentHeadless = (bin, args, options) => new Promise((resolve9, reject) =>
   });
   child.once("close", (code) => {
     clearTimeout(deadline);
-    resolve9({ code: code ?? 1, stderr, stdout, timedOut });
+    resolve11({ code: code ?? 1, stderr, stdout, timedOut });
   });
   child.once("exit", (code) => {
     if (timedOut) {
       clearTimeout(deadline);
-      resolve9({ code: code ?? 1, stderr, stdout, timedOut });
+      resolve11({ code: code ?? 1, stderr, stdout, timedOut });
     }
   });
   child.stdin.end(options.prompt);
@@ -17284,7 +18396,7 @@ var writeMcpConfig = async (dir, snapshotPath, launcher) => {
     args: [process.argv[1] ?? "", "mcp-stdio", "--data", snapshotPath],
     command: process.execPath
   };
-  const configPath = join35(dir, "mcp-config.json");
+  const configPath = join37(dir, "mcp-config.json");
   const config = {
     mcpServers: {
       [MCP_SERVER_NAME]: { args: resolved.args, command: resolved.command }
@@ -17392,17 +18504,17 @@ var readAgentOutput = async (kind, result, lastMessagePath) => {
       text: payload.data.result
     };
   }
-  let text;
+  let text2;
   try {
-    const raw = await readFile17(lastMessagePath, "utf-8");
-    text = raw.trim();
+    const raw = await readFile20(lastMessagePath, "utf-8");
+    text2 = raw.trim();
   } catch {
     return { detail: "no last message written", isError: true, text: "" };
   }
-  if (text === "") {
+  if (text2 === "") {
     return { detail: "empty last message", isError: true, text: "" };
   }
-  return { isError: false, text };
+  return { isError: false, text: text2 };
 };
 var verdictSchema = z3.object({
   missing: z3.array(z3.string()).default([]),
@@ -17410,15 +18522,15 @@ var verdictSchema = z3.object({
   pass: z3.boolean(),
   score: z3.number().min(0).max(1).optional()
 });
-var parseVerdict = (text) => {
-  const start = text.indexOf("{");
-  const end = text.lastIndexOf("}");
+var parseVerdict = (text2) => {
+  const start = text2.indexOf("{");
+  const end = text2.lastIndexOf("}");
   if (start === -1 || end <= start) {
     return;
   }
   let parsed;
   try {
-    parsed = JSON.parse(text.slice(start, end + 1));
+    parsed = JSON.parse(text2.slice(start, end + 1));
   } catch {
     return;
   }
@@ -17427,7 +18539,7 @@ var parseVerdict = (text) => {
 };
 
 // src/eval/schema.ts
-import { readFile as readFile18 } from "node:fs/promises";
+import { readFile as readFile21 } from "node:fs/promises";
 import { load as load2 } from "js-yaml";
 import { z as z4 } from "zod";
 var ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/u;
@@ -17472,7 +18584,7 @@ var describeIssues = (error) => error.issues.map((issue) => {
 var loadEvalsFile = async (path) => {
   let raw;
   try {
-    raw = await readFile18(path, "utf-8");
+    raw = await readFile21(path, "utf-8");
   } catch {
     throw new EvalsFileError(path, `No evals file found at ${path}. Run \`blume eval init\` to draft one.`);
   }
@@ -17564,9 +18676,9 @@ var errored = (question, detail, durationMs) => ({
 var runQuestion = async (question, index, context) => {
   const started = performance.now();
   const elapsed = () => Math.round(performance.now() - started);
-  const workDir = join36(context.dir, `work-${index}`);
-  await mkdir9(workDir, { recursive: true });
-  const answerPath = join36(workDir, "answer.txt");
+  const workDir = join38(context.dir, `work-${index}`);
+  await mkdir10(workDir, { recursive: true });
+  const answerPath = join38(workDir, "answer.txt");
   const reader = await context.run(context.bin, agentArgs(context.kind, { lastMessagePath: answerPath, mcp: context.mcp }), {
     cwd: workDir,
     prompt: readerPrompt(question),
@@ -17579,7 +18691,7 @@ var runQuestion = async (question, index, context) => {
       costUsd: answer.costUsd
     };
   }
-  const verdictPath = join36(workDir, "verdict.txt");
+  const verdictPath = join38(workDir, "verdict.txt");
   const judge = await context.run(context.bin, agentArgs(context.kind, { lastMessagePath: verdictPath }), {
     cwd: workDir,
     prompt: judgePrompt(question, answer.text),
@@ -17621,8 +18733,8 @@ var runEval = async (options) => {
   const kind = options.agent;
   const run = options.run ?? runAgentHeadless;
   const anchor = { path: options.evalsPath, raw: options.rawEvals };
-  const dir = await mkdtemp3(join36(tmpdir3(), "blume-eval-"));
-  const snapshotPath = join36(dir, "mcp-data.json");
+  const dir = await mkdtemp3(join38(tmpdir3(), "blume-eval-"));
+  const snapshotPath = join38(dir, "mcp-data.json");
   await writeFile14(snapshotPath, JSON.stringify(await buildMcpData(options.project)));
   const mcp = await writeMcpConfig(dir, snapshotPath);
   const context = {
@@ -17760,8 +18872,8 @@ var runFixHandoff = async (agent, result, root, threshold) => {
   }
 };
 var runInit = async (agent, file) => {
-  const path = join37(process.cwd(), file);
-  if (existsSync20(path)) {
+  const path = join39(process.cwd(), file);
+  if (existsSync22(path)) {
     logger.error(`${file} already exists — edit it directly, or pass --file to draft elsewhere.`);
     process.exit(1);
   }
@@ -17825,7 +18937,7 @@ var evalCommand = defineCommand8({
     let result;
     try {
       const project = await scanProject(root, { mode: "build" });
-      const evalsPath = join37(root, args.file);
+      const evalsPath = join39(root, args.file);
       const { evals, raw } = await loadEvalsFile(evalsPath);
       process.stderr.write(`${headerLine(evals.questions.length, agent)}
 
@@ -17899,10 +19011,10 @@ var evalCommand = defineCommand8({
 // src/cli/commands/init.ts
 import * as clack from "@clack/prompts";
 import { defineCommand as defineCommand9 } from "citty";
-import { resolve as resolve10 } from "pathe";
+import { resolve as resolve12 } from "pathe";
 
 // src/cli/init/questions.ts
-import { basename as basename6, resolve as resolve9 } from "pathe";
+import { basename as basename6, resolve as resolve11 } from "pathe";
 var cancelled = (value) => typeof value === "symbol";
 var collectAnswers = async (prompter, flags, defaults) => {
   const directory = flags.directory ?? await prompter.text({
@@ -17913,7 +19025,7 @@ var collectAnswers = async (prompter, flags, defaults) => {
   if (cancelled(directory)) {
     return null;
   }
-  const root = resolve9(defaults.cwd, directory);
+  const root = resolve11(defaults.cwd, directory);
   const title = await prompter.text({
     initialValue: titleize(basename6(root)),
     message: "What's your docs site called?",
@@ -18082,7 +19194,7 @@ var initCommand = defineCommand9({
         title: "My Docs"
       };
     }
-    const root = resolve10(cwd, answers.directory);
+    const root = resolve12(cwd, answers.directory);
     if (validateContentDir(root, answers.contentDir) !== undefined) {
       logger.error(`Invalid --content-dir "${answers.contentDir}" (must be a path inside the project).`);
       process.exit(1);
@@ -18112,7 +19224,7 @@ var initCommand = defineCommand9({
 });
 
 // src/cli/commands/mcp-stdio.ts
-import { readFile as readFile19 } from "node:fs/promises";
+import { readFile as readFile22 } from "node:fs/promises";
 import { defineCommand as defineCommand10 } from "citty";
 
 // src/ai/mcp/stdio.ts
@@ -18137,19 +19249,83 @@ var SCHEMA = {
   title: "string"
 };
 var BOOST = { description: 2, title: 3 };
-var buildOramaIndex = async (documents) => {
-  const db = create({ schema: SCHEMA });
+var SEGMENTED_LANGUAGES = new Set(["ja", "ko", "th", "zh"]);
+var BIGRAM_LANGUAGES = new Set(["ja", "zh"]);
+var BIGRAM_SCRIPTS = /^[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}々〆〇ーﾞﾟ]+$/u;
+var addBigrams = (run, tokens) => {
+  const characters = [...run];
+  if (characters.length === 1) {
+    tokens.add(run);
+    return;
+  }
+  let previous = "";
+  for (const character of characters) {
+    if (previous) {
+      tokens.add(previous + character);
+    }
+    previous = character;
+  }
+};
+var segmentingTokenizer = (locale) => {
+  const language = locale?.toLowerCase().split(/[-_]/u)[0] ?? "";
+  if (!SEGMENTED_LANGUAGES.has(language)) {
+    return;
+  }
+  if (typeof Intl.Segmenter !== "function") {
+    return;
+  }
+  const segmenter = new Intl.Segmenter(language, { granularity: "word" });
+  const bigram = BIGRAM_LANGUAGES.has(language);
+  return {
+    language,
+    normalizationCache: new Map,
+    tokenize: (raw) => {
+      const tokens = new Set;
+      let run = "";
+      const flush = () => {
+        if (run) {
+          addBigrams(run, tokens);
+          run = "";
+        }
+      };
+      for (const segment of segmenter.segment(raw.toLowerCase())) {
+        if (!segment.isWordLike) {
+          flush();
+          continue;
+        }
+        if (bigram && BIGRAM_SCRIPTS.test(segment.segment)) {
+          run += segment.segment;
+          continue;
+        }
+        flush();
+        tokens.add(segment.segment);
+      }
+      flush();
+      return [...tokens];
+    }
+  };
+};
+var buildOramaIndex = async (documents, locale) => {
+  const tokenizer = segmentingTokenizer(locale);
+  const db = create({
+    schema: SCHEMA,
+    ...tokenizer ? { components: { tokenizer } } : {}
+  });
   await insertMultiple(db, documents);
   return db;
 };
+var ALL_TOKENS = 0;
 var queryOramaIndex = async (db, term, limit, locale) => {
-  const found = await search(db, {
+  const params = {
     boost: BOOST,
     limit,
     properties: ["title", "description", "content"],
     term,
     ...locale ? { where: { locale: { eq: locale } } } : {}
-  });
+  };
+  const bigrammed = BIGRAM_LANGUAGES.has(db.tokenizer?.language ?? "");
+  const strict = bigrammed ? await search(db, { ...params, threshold: ALL_TOKENS }) : undefined;
+  const found = strict && strict.hits.length > 0 ? strict : await search(db, params);
   return found.hits.map((hit) => hit.document);
 };
 
@@ -18226,14 +19402,14 @@ var excerptFor = (doc) => {
   const head = doc.content.slice(0, EXCERPT_LENGTH).trim();
   return doc.content.length > EXCERPT_LENGTH ? `${head}…` : head;
 };
-var text = (value, isError = false) => ({
+var text2 = (value, isError = false) => ({
   content: [{ text: value, type: "text" }],
   ...isError ? { isError: true } : {}
 });
-var createIndexProvider = (documents) => {
+var createIndexProvider = (documents, locale) => {
   let dbPromise = null;
-  return () => {
-    dbPromise ??= buildOramaIndex(documents);
+  return function provideIndex() {
+    dbPromise ??= buildOramaIndex(documents, locale);
     return dbPromise;
   };
 };
@@ -18256,18 +19432,18 @@ var buildServer = (data, index) => {
         title: doc.title,
         url: urlFor(doc.route, data)
       }));
-      return text(JSON.stringify(results, null, 2));
+      return text2(JSON.stringify(results, null, 2));
     }
     if (name === "get_page") {
       const key = normalizeRoute2(asString2(args.route), data);
       const markdown = data.pages[key];
       if (markdown === undefined) {
-        return text(`No page found at "${key}". Use list_pages or search_docs to find valid routes.`, true);
+        return text2(`No page found at "${key}". Use list_pages or search_docs to find valid routes.`, true);
       }
-      return text(markdown);
+      return text2(markdown);
     }
     if (name === "list_pages") {
-      return text(JSON.stringify(data.routes.map((route) => ({
+      return text2(JSON.stringify(data.routes.map((route) => ({
         contentType: route.contentType,
         description: route.description,
         lastModified: route.lastModified,
@@ -18277,9 +19453,9 @@ var buildServer = (data, index) => {
       })), null, 2));
     }
     if (name === "get_navigation") {
-      return text(JSON.stringify(data.navigation, null, 2));
+      return text2(JSON.stringify(data.navigation, null, 2));
     }
-    return text(`Unknown tool: ${name}`, true);
+    return text2(`Unknown tool: ${name}`, true);
   });
   return server;
 };
@@ -18289,7 +19465,7 @@ var serveMcpStdio = async (data, streams = {}) => {
   const stdin = streams.stdin ?? process.stdin;
   const stdout = streams.stdout ?? process.stdout;
   const transport = new StdioServerTransport(stdin, stdout);
-  const server = buildServer(data, createIndexProvider(data.documents));
+  const server = buildServer(data, createIndexProvider(data.documents, data.defaultLocale));
   await server.connect(transport);
   await once(stdin, "end");
   await transport.close();
@@ -18311,7 +19487,7 @@ var mcpStdioCommand = defineCommand10({
   async run({ args }) {
     let data;
     try {
-      data = JSON.parse(await readFile19(args.data, "utf-8"));
+      data = JSON.parse(await readFile22(args.data, "utf-8"));
     } catch (error) {
       const detail = error instanceof Error ? error.message : String(error);
       process.stderr.write(`blume mcp-stdio: cannot load the snapshot at ${args.data}: ${detail}
@@ -18323,10 +19499,10 @@ var mcpStdioCommand = defineCommand10({
 });
 
 // src/cli/commands/preview.ts
-import { existsSync as existsSync21 } from "node:fs";
+import { existsSync as existsSync23 } from "node:fs";
 import { preview } from "astro";
 import { defineCommand as defineCommand11 } from "citty";
-import { join as join38 } from "pathe";
+import { join as join40 } from "pathe";
 var previewCommand = defineCommand11({
   args: {
     host: { description: "Network host to bind.", type: "string" },
@@ -18340,7 +19516,7 @@ var previewCommand = defineCommand11({
     const root = process.cwd();
     const { config } = await loadConfig(root);
     const context = resolveProjectContext(root, config);
-    if (!existsSync21(join38(context.outDir, "astro.config.mjs"))) {
+    if (!existsSync23(join40(context.outDir, "astro.config.mjs"))) {
       logger.error("No build found. Run `blume build` first.");
       process.exit(1);
     }
@@ -18358,7 +19534,7 @@ var previewCommand = defineCommand11({
 // src/cli/commands/sync.ts
 import { rm as rm4 } from "node:fs/promises";
 import { defineCommand as defineCommand12 } from "citty";
-import { join as join39 } from "pathe";
+import { join as join41 } from "pathe";
 var syncCommand = defineCommand12({
   args: {
     force: {
@@ -18380,7 +19556,7 @@ var syncCommand = defineCommand12({
     if (args.force) {
       const { config } = await loadConfig(root);
       const context = resolveProjectContext(root, config);
-      await rm4(join39(context.outDir, "cache"), { force: true, recursive: true });
+      await rm4(join41(context.outDir, "cache"), { force: true, recursive: true });
       logger.info("Cleared source cache.");
     }
     const lock = readDevLock(resolveRuntimeDir(root));
@@ -18398,13 +19574,13 @@ var syncCommand = defineCommand12({
 });
 
 // src/cli/commands/validate.ts
-import { existsSync as existsSync23 } from "node:fs";
+import { existsSync as existsSync25 } from "node:fs";
 import { defineCommand as defineCommand13 } from "citty";
-import { join as join41 } from "pathe";
+import { join as join43 } from "pathe";
 
 // src/core/links.ts
-import { existsSync as existsSync22 } from "node:fs";
-import { basename as basename7, join as join40 } from "pathe";
+import { existsSync as existsSync24 } from "node:fs";
+import { basename as basename7, join as join42 } from "pathe";
 var HTTP = /^https?:\/\//iu;
 var PROTOCOL_RELATIVE = /^\/\//u;
 var SCHEME = /^[a-z][a-z0-9+.-]*:/iu;
@@ -18417,7 +19593,7 @@ var decodePercent = (value) => {
 };
 var DOC_EXT = /\.(?:md|mdx)$/iu;
 var FILE_EXT = /\.[a-z0-9]+$/iu;
-var assetIsPresent = (resolved, ctx) => ctx.publicDir !== null && existsSync22(join40(ctx.publicDir, resolved));
+var assetIsPresent = (resolved, ctx) => ctx.publicDir !== null && existsSync24(join42(ctx.publicDir, resolved));
 var NUMERIC_PREFIX3 = /^\d+[-_.]/u;
 var isIndexPage = (page2) => /^index\.(?:md|mdx)$/iu.test(basename7(page2.navPath).replace(NUMERIC_PREFIX3, ""));
 var applyRelativePart = (segments, part) => {
@@ -18628,12 +19804,12 @@ var validateCommand = defineCommand13({
         });
         extraRoutes.push(...manifest.routes.flatMap((route) => route.fallback ? [route.path] : []));
       }
-      const publicDir = join41(root, "public");
+      const publicDir = join43(root, "public");
       diagnostics.push(...await validateLinks(project.graph, {
         basePath: project.config.basePath,
         checkExternal: Boolean(args.external),
         extraRoutes,
-        publicDir: existsSync23(publicDir) ? publicDir : null,
+        publicDir: existsSync25(publicDir) ? publicDir : null,
         redirects: project.config.redirects
       }));
     } catch (error) {
@@ -18697,5 +19873,5 @@ process.on("unhandledRejection", (error) => {
 });
 runMain(main);
 
-//# debugId=E4DFD2C6131D546564756E2164756E21
+//# debugId=CCE85D85BA5F467464756E2164756E21
 //# sourceMappingURL=index.js.map