blume 1.7.2 → 2.0.0

package/dist/cli/{chunk-ejjx8znq.js → chunk-mnqj32sj.js}

@@ -1,167 +1,121 @@
 #!/usr/bin/env node
 import {
-  OPENAPI_PATH,
-  API_CATALOG_PATH,
-  hasApiCatalog
-} from "./chunk-tqa1s0k8.js";
+  trimChar,
+  normalizeBasePath
+} from "./chunk-jts8mvcz.js";
 import {
-  hasScalarReferences,
+  buildHomeLinkHeader,
+  resolveDocsCollection,
+  TOC_HIDDEN_KEY,
+  deployPassthrough,
   fontLocaleCodes,
-  buildFontEntries
-} from "./chunk-61j18dwk.js";
+  buildFontEntries,
+  applyBaseToAstroRedirects,
+  distDir,
+  adapterRoot,
+  SVG_ASSET_POLICY,
+  deployPlatform
+} from "./chunk-xaz13gwg.js";
 import {
-  searchProviderMeta
-} from "./chunk-q4rae3bg.js";
-import {
-  TOC_HIDDEN_KEY,
   BLUME_IGNORE_DIRS
-} from "./chunk-hdm2dkd2.js";
-import {
-  trimChar,
-  normalizeBasePath,
-  withBasePath,
-  withComposedBasePath
-} from "./chunk-2mzebbbz.js";
-
-// src/deploy/adapter-output.ts
-import { existsSync } from "node:fs";
-import { cp, mkdir, rm } from "node:fs/promises";
-import { dirname, join } from "pathe";
-var ADAPTER_IGNORE_DIRS = {
-  netlify: ".netlify/",
-  vercel: ".vercel/"
-};
-var ADAPTER_OUTPUT_PATHS = {
-  netlify: ".netlify/v1"
-};
-var servesClientSubdir = (deployment) => deployment.output === "server" && (deployment.adapter === "node" || deployment.adapter === "cloudflare");
-var deployStaticDir = (config, context) => {
-  const { adapter, output } = config.deployment;
-  if (output === "server" && adapter === "vercel") {
-    return join(context.root, ".vercel", "output", "static");
-  }
-  const dist = context.distDir ?? join(context.root, "dist");
-  if (servesClientSubdir(config.deployment)) {
-    return join(dist, "client");
-  }
-  return dist;
-};
-var surfaceAdapterOutput = async (config, context) => {
-  const { adapter, output } = config.deployment;
-  if (output !== "server" || !adapter) {
-    return { moved: false };
-  }
-  const rel = ADAPTER_OUTPUT_PATHS[adapter];
-  if (!rel) {
-    return { moved: false };
-  }
-  const from = join(context.outDir, rel);
-  const to = join(context.root, rel);
-  if (!existsSync(from)) {
-    return { moved: false };
+} from "./chunk-abh8yjkn.js";
+
+// src/astro/component-slots.ts
+import { isAbsolute, join, relative } from "pathe";
+var attributeValue = (value) => value.replaceAll(/["\n\r]/gu, " ").trim();
+var CLIENT_LOAD = "client:load";
+var directiveFor = (override) => {
+  const { framework } = override.source;
+  switch (override.client) {
+    case "idle": {
+      return "client:idle";
+    }
+    case "visible": {
+      return "client:visible";
+    }
+    case "media": {
+      return override.media ? `client:media="${attributeValue(override.media)}"` : CLIENT_LOAD;
+    }
+    case "only": {
+      return framework ? `client:only="${attributeValue(framework)}"` : CLIENT_LOAD;
+    }
+    default: {
+      return CLIENT_LOAD;
+    }
   }
-  await mkdir(dirname(to), { recursive: true });
-  await rm(to, { force: true, recursive: true });
-  await cp(from, to, { recursive: true, verbatimSymlinks: true });
-  await rm(from, { force: true, recursive: true });
-  return { from, moved: true, to };
 };
-
-// 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.ai.api) {
-    links.push(`<${deployBase}${OPENAPI_PATH}>; rel="service-desc"; type="application/json"`);
+var importSpecifier = (path, fromDir) => {
+  if (fromDir === undefined || !isAbsolute(path)) {
+    return path;
   }
-  if (config.seo.agentReadability) {
-    links.push(`<${deployBase}/agent-readability.json>; rel="describedby"; type="application/json"`);
+  const specifier = relative(fromDir, path);
+  if (isAbsolute(specifier) || specifier.startsWith("../")) {
+    return specifier;
   }
-  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;
+  return `./${specifier}`;
 };
-
-// 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 platformRedirects = (config) => applyBaseToPlatformRedirects(config.redirects, config.basePath, config.deployment.base ?? "");
-
-// src/ai/ask.ts
-var OPENAI_COMPATIBLE = "openai-compatible";
-var OPENAI_COMPATIBLE_DEP = "@ai-sdk/openai-compatible";
-var ASK_PRESETS = {
-  inkeep: {
-    apiKeyEnv: "INKEEP_API_KEY",
-    baseUrl: "https://api.inkeep.com/v1",
-    kind: OPENAI_COMPATIBLE,
-    name: "inkeep",
-    runtimeDep: OPENAI_COMPATIBLE_DEP
-  },
-  llmgateway: {
-    apiKeyEnv: "LLMGATEWAY_API_KEY",
-    baseUrl: "https://api.llmgateway.io/v1",
-    kind: OPENAI_COMPATIBLE,
-    name: "llmgateway",
-    runtimeDep: OPENAI_COMPATIBLE_DEP
-  },
-  openrouter: {
-    apiKeyEnv: "OPENROUTER_API_KEY",
-    kind: "openrouter",
-    name: "openrouter",
-    runtimeDep: "@openrouter/ai-sdk-provider"
-  }
-};
-var DEFAULT_MODEL = "openai/gpt-5.5";
-var askHeadersField = (ask) => ask?.headers && Object.keys(ask.headers).length > 0 ? { headers: ask.headers } : {};
-var resolveAskBackend = (ask) => {
-  const provider = ask?.provider ?? "gateway";
-  const model = ask?.model ?? DEFAULT_MODEL;
-  const headers = askHeadersField(ask);
-  if (provider === "gateway") {
-    return { ...headers, kind: "gateway", model };
-  }
-  const preset = ASK_PRESETS[provider];
-  const apiKeyEnv = ask?.apiKeyEnv ?? preset?.apiKeyEnv ?? "API_KEY";
-  if (provider === "openrouter") {
-    return { apiKeyEnv, ...headers, kind: "openrouter", model };
-  }
-  return {
-    apiKeyEnv,
-    baseUrl: ask?.baseUrl ?? preset?.baseUrl ?? "",
-    ...headers,
-    kind: OPENAI_COMPATIBLE,
-    model,
-    name: preset?.name ?? OPENAI_COMPATIBLE
+var importClause = (variable, name, path) => name === "default" ? `import ${variable} from ${JSON.stringify(path)};` : `import { ${name} as ${variable} } from ${JSON.stringify(path)};`;
+var wrapperPropsType = (name) => `type Props = typeof ${name} extends (
+  props: infer P extends object,
+  ...rest: never[]
+) => unknown
+  ? P
+  : Record<string, unknown>;`;
+var wrapperContent = (override, fromDir) => `---
+// Generated by Blume. Do not edit.
+${importClause("Component", override.source.name, importSpecifier(override.source.path, fromDir))}
+${wrapperPropsType("Component")}
+---
+<Component ${directiveFor(override)} {...Astro.props}><slot /></Component>
+`;
+var sanitize = (value) => value.replaceAll(/[^A-Za-z0-9]/gu, (char) => `_${(char.codePointAt(0) ?? 0).toString(16)}_`);
+var islandOverride = (island) => ({
+  client: island.client,
+  key: island.name,
+  source: { framework: island.framework, name: "default", path: island.file }
+});
+var record = (entries) => entries.length ? `{ ${entries.join(", ")} }` : "{}";
+var planComponentSlots = (islands, analysis, options = {}) => {
+  const { relativeTo } = options;
+  const wrapperDir = relativeTo === undefined ? undefined : join(relativeTo, "component-slots");
+  const frameworks = new Set;
+  const wrappers = [];
+  const importLines = [];
+  let counter = 0;
+  const plan = (overrides, group) => {
+    const byKey = new Map;
+    for (const override of overrides) {
+      byKey.set(override.key, override);
+    }
+    const entries = [];
+    for (const override of byKey.values()) {
+      const { source } = override;
+      if (source.framework) {
+        frameworks.add(source.framework);
+      }
+      const variable = `__blumeSlot${counter}`;
+      counter += 1;
+      if (override.client) {
+        const name = `${group}-${sanitize(override.key)}`;
+        wrappers.push({ content: wrapperContent(override, wrapperDir), name });
+        importLines.push(importClause(variable, "default", `./component-slots/${name}.astro`));
+      } else {
+        importLines.push(importClause(variable, source.name, importSpecifier(source.path, relativeTo)));
+      }
+      entries.push(`${JSON.stringify(override.key)}: ${variable}`);
+    }
+    return entries;
   };
-};
-var askBackendRuntimeDep = (ask) => {
-  const provider = ask?.provider ?? "gateway";
-  if (provider === "gateway") {
-    return;
-  }
-  return ASK_PRESETS[provider]?.runtimeDep ?? OPENAI_COMPATIBLE_DEP;
+  const mdxEntries = plan([...islands.map(islandOverride), ...analysis.mdx], "mdx");
+  const layoutEntries = plan(analysis.layout, "layout");
+  const module = `// Generated by Blume. Do not edit.
+import type { ComponentOverride } from "blume/core/define-components.ts";
+${importLines.join(`
+`)}${importLines.length ? `
+` : ""}export const mdxComponents: Record<string, ComponentOverride> = ${record(mdxEntries)};
+export const layoutOverrides: Record<string, ComponentOverride> = ${record(layoutEntries)};
+`;
+  return { frameworks, module, wrappers };
 };
 
 // src/astro/runtime-modules.ts
@@ -214,9 +168,9 @@ var publishRuntimeModules = (modules) => {
 };
 
 // src/astro/templates.ts
-import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { pathToFileURL } from "node:url";
-import { dirname as dirname2, isAbsolute, join as join2, relative } from "pathe";
+import { dirname, isAbsolute as isAbsolute2, join as join2, relative as relative2 } from "pathe";
 var WORKSPACE_MARKERS = [
   ".git",
   "bun.lock",
@@ -227,7 +181,7 @@ var WORKSPACE_MARKERS = [
   "yarn.lock"
 ];
 var hasWorkspacesField = (pkgPath) => {
-  if (!existsSync2(pkgPath)) {
+  if (!existsSync(pkgPath)) {
     return false;
   }
   try {
@@ -237,51 +191,42 @@ var hasWorkspacesField = (pkgPath) => {
     return false;
   }
 };
-var hasWorkspaceMarker = (dir) => hasWorkspacesField(join2(dir, "package.json")) || WORKSPACE_MARKERS.some((marker) => existsSync2(join2(dir, marker)));
+var hasWorkspaceMarker = (dir) => hasWorkspacesField(join2(dir, "package.json")) || WORKSPACE_MARKERS.some((marker) => existsSync(join2(dir, marker)));
 var findWorkspaceRoot = (start) => {
   let dir = start;
   for (;; ) {
     if (hasWorkspaceMarker(dir)) {
       return dir;
     }
-    const parent = dirname2(dir);
+    const parent = dirname(dir);
     if (parent === dir) {
       return start;
     }
     dir = parent;
   }
 };
-var ADAPTER_IMPORTS = {
-  cloudflare: "@astrojs/cloudflare",
-  netlify: "@astrojs/netlify",
-  node: "@astrojs/node",
-  vercel: "@astrojs/vercel"
-};
-var ADAPTER_OPTIONS = new Map([
-  ["node", '{ mode: "standalone" }']
-]);
-var WRANGLER_CONFIG_FILES = [
-  "wrangler.jsonc",
-  "wrangler.json",
-  "wrangler.toml"
-];
-var resolveCloudflareAdapterArgs = (context) => {
-  const args = [
-    'prerenderEnvironment: "node"',
-    'imageService: "compile"'
-  ];
-  const wranglerPath = WRANGLER_CONFIG_FILES.map((file) => join2(context.root, file)).find((file) => existsSync2(file));
-  if (wranglerPath) {
-    let configPath = relative(context.outDir, wranglerPath);
-    if (!configPath.startsWith(".") && !configPath.startsWith("/")) {
-      configPath = `./${configPath}`;
-    }
-    args.push(`configPath: ${JSON.stringify(configPath)}`);
+var renderAstroAdapter = (deployment, context, ejected) => {
+  const platform = deployPlatform(deployment);
+  if (deployment.options.output !== "server" || !platform.astro) {
+    return { configEntries: "", importLine: "", option: "" };
   }
-  return `{ ${args.join(", ")} }`;
+  const { astro } = platform;
+  const args = {
+    ...astro.options(context),
+    ...deployPassthrough(deployment.options)
+  };
+  const argsLiteral = Object.keys(args).length > 0 ? JSON.stringify(args) : "";
+  const construct = `adapter(${argsLiteral})`;
+  const expression = platform.hiddenRuntime.showProjectRoot && !ejected ? `withAdapterRoot(${construct}, ${JSON.stringify(adapterRoot(context))})` : construct;
+  return {
+    configEntries: Object.entries(astro.config).map(([key, value]) => `
+  ${key}: ${JSON.stringify(value)},`).join(""),
+    importLine: `import adapter from "${astro.package}";
+`,
+    option: `
+  adapter: ${expression},`
+  };
 };
-var resolveSessionOption = (deployment) => deployment.output === "server" && deployment.adapter === "cloudflare" ? `
-  session: false,` : "";
 var astroFontWeights = (weights) => JSON.stringify(weights).replaceAll(/(?<min>\d+)\.\.(?<max>\d+)/gu, "$<min> $<max>");
 var astroConfigImportLine = (options) => {
   const names = ["defineConfig"];
@@ -302,23 +247,18 @@ var runtimeDependencies = (options) => {
   if (needsSvelte) {
     deps.push("@astrojs/svelte");
   }
-  if (hasScalarReferences(config)) {
-    deps.push("@scalar/astro");
-  }
-  deps.push(...searchProviderMeta(config.search.provider).runtimeDeps);
-  if (config.ai.ask?.enabled && !config.ai.ask.endpoint) {
-    const askDep = askBackendRuntimeDep(config.ai.ask);
-    if (askDep) {
-      deps.push(askDep);
+  deps.push(...new Set(config.reference.flatMap((adapter) => adapter.runtimeDeps)), ...config.search.provider.runtimeDeps, ...config.analytics.flatMap((adapter) => adapter.runtimeDeps));
+  for (const source of config.content.sources) {
+    for (const dep of source.runtimeDeps) {
+      if (!deps.includes(dep)) {
+        deps.push(dep);
+      }
     }
   }
-  const { deployment } = config;
-  if (deployment.output === "server" && deployment.adapter) {
-    const adapter = ADAPTER_IMPORTS[deployment.adapter];
-    if (adapter) {
-      deps.push(adapter);
-    }
+  if (config.ai.ask?.enabled && !config.ai.ask.endpoint) {
+    deps.push(...config.ai.ask.provider.runtimeDeps);
   }
+  deps.push(...config.deployment.runtimeDeps);
   return deps;
 };
 var RENDER_EXTERNAL_DEPS = [
@@ -338,8 +278,6 @@ var RENDER_EXTERNAL_DEPS = [
 ];
 var renderUserAliases = (aliases) => Object.entries(aliases ?? {}).toSorted(([a], [b]) => b.length - a.length).map(([find, replacement]) => `
         ${JSON.stringify(find)}: ${JSON.stringify(replacement)},`).join("");
-var astroOutDir = (context) => context.distDir ?? `${context.root}/dist`;
-var adapterRoot = (context) => dirname2(astroOutDir(context));
 var REACT_EXCLUDE = String.raw`exclude: [/\/node_modules\/\.vite\//, /\/\.cache\/vite\//]`;
 var runtimeCacheOptions = (context, generatedModulesDir) => {
   if (generatedModulesDir !== undefined) {
@@ -393,6 +331,17 @@ var resolveOptimizeDeps = (options) => {
   ];
   return { optimizeDepsEntries, optimizeDepsInclude };
 };
+var configPath = (path, ejected) => ejected ? `fileURLToPath(new URL(${JSON.stringify(path)}, import.meta.url))` : JSON.stringify(path);
+var EJECTED_CONFIG_HEADER = "// Written by `blume eject`. This is your Astro config now: edit it freely.";
+var astroConfigHeader = (ejected) => ejected ? EJECTED_CONFIG_HEADER : "// Generated by Blume. Do not edit; this file is recreated on each run.";
+var MERMAID_CHUNK_LIMIT = `
+      chunkSizeWarningLimit: 2048,`;
+var ROLLDOWN_ON_LOG = `onLog(level, log, handler) {
+          if (log.code === "MODULE_LEVEL_DIRECTIVE" && String(log.message).includes("use astro:head-inject")) {
+            return;
+          }
+          handler(level, log);
+        }`;
 var renderRuntimeModuleWiring = (generatedModulesDir) => {
   if (generatedModulesDir === undefined) {
     return {
@@ -402,7 +351,7 @@ var renderRuntimeModuleWiring = (generatedModulesDir) => {
     };
   }
   const aliasLines = [...RUNTIME_MODULE_FILES].map(([id, file]) => `
-        ${JSON.stringify(id)}: ${JSON.stringify(`${generatedModulesDir}/${file}`)},`).join("");
+        ${JSON.stringify(id)}: ${configPath(`${generatedModulesDir}/${file}`, true)},`).join("");
   return { aliasLines, imports: [], pluginEntry: "" };
 };
 var blumeIntegrationOptions = (options) => options.ejected ? {
@@ -426,6 +375,7 @@ var astroConfigTemplate = (options) => {
     needsVue,
     searchClientPath
   } = options;
+  const ejected = generatedModulesDir !== undefined;
   const {
     aliasLines: runtimeModuleAliasLines,
     imports: runtimeModuleImports,
@@ -433,7 +383,6 @@ var astroConfigTemplate = (options) => {
   } = renderRuntimeModuleWiring(generatedModulesDir);
   const { deployment } = config;
   const userAliasLines = renderUserAliases(options.aliases);
-  const server = deployment.output === "server";
   const fsAllow = [...new Set([findWorkspaceRoot(context.root), context.root])];
   const { optimizeDepsEntries, optimizeDepsInclude } = resolveOptimizeDeps({
     aliases: options.aliases,
@@ -442,25 +391,15 @@ var astroConfigTemplate = (options) => {
     needsReact,
     reactCompilerPath: options.reactCompilerPath
   });
-  const adapterImport = server && deployment.adapter ? `import adapter from "${ADAPTER_IMPORTS[deployment.adapter]}";
-` : "";
-  const adapterArgs = (() => {
-    if (!server || !deployment.adapter) {
-      return "";
-    }
-    if (deployment.adapter === "cloudflare") {
-      return resolveCloudflareAdapterArgs(context);
-    }
-    return ADAPTER_OPTIONS.get(deployment.adapter) ?? "";
-  })();
-  const adapterExpr = deployment.adapter === "vercel" ? `withAdapterRoot(adapter(${adapterArgs}), ${JSON.stringify(adapterRoot(context))})` : `adapter(${adapterArgs})`;
-  const adapterOption = server && deployment.adapter ? `
-  adapter: ${adapterExpr},` : "";
-  const sessionOption = resolveSessionOption(deployment);
-  const siteOption = deployment.site ? `
-  site: ${JSON.stringify(deployment.site)},` : "";
-  const baseOption = deployment.base ? `
-  base: ${JSON.stringify(deployment.base)},` : "";
+  const {
+    configEntries: adapterConfigEntries,
+    importLine: adapterImport,
+    option: adapterOption
+  } = renderAstroAdapter(deployment, context, ejected);
+  const siteOption = deployment.options.site ? `
+  site: ${JSON.stringify(deployment.options.site)},` : "";
+  const baseOption = deployment.options.base ? `
+  base: ${JSON.stringify(deployment.options.base)},` : "";
   const imageOption = renderImageOption(config);
   const i18nOption = config.i18n ? `
   i18n: ${JSON.stringify({
@@ -470,7 +409,7 @@ var astroConfigTemplate = (options) => {
       prefixDefaultLocale: !config.i18n.hideDefaultLocalePrefix
     }
   })},` : "";
-  const basedRedirects = applyBaseToAstroRedirects(config.redirects, config.basePath, deployment.base ?? "");
+  const basedRedirects = applyBaseToAstroRedirects(config.redirects, config.basePath, deployment.options.base ?? "");
   const redirectsOption = basedRedirects.length > 0 ? `
   redirects: ${JSON.stringify(Object.fromEntries(basedRedirects.map((redirect) => [
     redirect.from,
@@ -489,7 +428,7 @@ var astroConfigTemplate = (options) => {
     return {
       ...face,
       src: [
-        isAbsolute(variant.src) ? variant.src : join2(context.root, variant.src)
+        isAbsolute2(variant.src) ? variant.src : join2(context.root, variant.src)
       ]
     };
   }))} } }` : `{ provider: fontProviders.${font.provider}(), name: ${JSON.stringify(font.name)}, cssVariable: ${JSON.stringify(font.cssVariable)}, weights: ${astroFontWeights(font.weights)}, subsets: ${JSON.stringify(font.subsets)}, fallbacks: ${JSON.stringify(font.fallbacks)} }`).join(", ")}],` : "";
@@ -512,15 +451,18 @@ var astroConfigTemplate = (options) => {
   const blumeImport = `import { ${blumeImports.join(", ")} } from "blume/astro";
 `;
   const twoslashTransformer = "blumeTwoslashTransformer(), ";
-  const deployBase = normalizeBasePath(deployment.base);
+  const deployBase = normalizeBasePath(deployment.options.base);
+  const processorLiteral = JSON.stringify({
+    basePath: config.basePath,
+    codeThemes: config.markdown.code.theme,
+    contentRoot: options.contentRoot,
+    deployBase,
+    externalLinks: config.markdown.externalLinks,
+    headingAnchors: config.markdown.headingAnchors
+  });
+  const processorOptions = options.generatedModulesDir === undefined ? processorLiteral : `{ ...${processorLiteral}, dataFile: ${configPath(`${options.generatedModulesDir}/data.json`, true)} }`;
   const integrations = [
-    `mdx({ processor: blumeMdxProcessor(${JSON.stringify({
-      basePath: config.basePath,
-      codeThemes: config.markdown.codeBlocks.theme,
-      contentRoot: options.contentRoot,
-      deployBase,
-      headingAnchors: config.markdown.headingAnchors
-    })}) })`
+    `mdx({ processor: blumeMdxProcessor(${processorOptions}) })`
   ];
   if (needsReact) {
     integrations.push(reactIntegration(options.reactCompilerPath));
@@ -534,7 +476,7 @@ var astroConfigTemplate = (options) => {
   integrations.push(`blumeIntegration(${JSON.stringify(blumeIntegrationOptions({
     config,
     contentRoutes,
-    ejected: generatedModulesDir !== undefined,
+    ejected,
     pages
   }))})`);
   const {
@@ -543,9 +485,11 @@ var astroConfigTemplate = (options) => {
     userConfigSetup,
     userIntegrationSpread
   } = renderIntegrationBridge(options.integrationBridge);
-  return `// Generated by Blume. Do not edit; this file is recreated on each run.
+  const fileUrlImport = ejected ? `import { fileURLToPath } from "node:url";
+` : "";
+  return `${astroConfigHeader(ejected)}
 ${configSourceMarker}${userConfigImports}import { availableParallelism } from "node:os";
-${defineConfigImport}
+${fileUrlImport}${defineConfigImport}
 import mdx from "@astrojs/mdx";
 import tailwindcss from "@tailwindcss/vite";
 import { blumeMarkdownProcessor, blumeMdxProcessor, blumeShikiTransformers, blumeTwoslashTransformer } from "blume/markdown";
@@ -553,22 +497,16 @@ ${reactImport}${vueImport}${svelteImport}${blumeImport}${adapterImport}
 ${userConfigSetup}export default defineConfig({
   root: ${JSON.stringify(context.outDir)},
   srcDir: ${JSON.stringify(`${context.outDir}/src`)},
-  outDir: ${JSON.stringify(astroOutDir(context))},
+  outDir: ${JSON.stringify(distDir(context))},
   publicDir: ${JSON.stringify(`${context.root}/public`)},${cacheOptions}
-  output: ${JSON.stringify(deployment.output)},${adapterOption}${sessionOption}${siteOption}${baseOption}${imageOption}${redirectsOption}${i18nOption}${fontsOption}
+  output: ${JSON.stringify(deployment.options.output)},${adapterOption}${adapterConfigEntries}${siteOption}${baseOption}${imageOption}${redirectsOption}${i18nOption}${fontsOption}
   integrations: [${integrations.join(", ")}${userIntegrationSpread}],
   markdown: {
-    processor: blumeMarkdownProcessor(${JSON.stringify({
-    basePath: config.basePath,
-    codeThemes: config.markdown.codeBlocks.theme,
-    contentRoot: options.contentRoot,
-    deployBase,
-    headingAnchors: config.markdown.headingAnchors
-  })}),
+    processor: blumeMarkdownProcessor(${processorOptions}),
     shikiConfig: {
       themes: {
-        light: ${JSON.stringify(config.markdown.codeBlocks.theme.light)},
-        dark: ${JSON.stringify(config.markdown.codeBlocks.theme.dark)},
+        light: ${JSON.stringify(config.markdown.code.theme.light)},
+        dark: ${JSON.stringify(config.markdown.code.theme.dark)},
       },
       defaultColor: false,
       transformers: [${twoslashTransformer}...blumeShikiTransformers(${JSON.stringify({ icons: config.markdown.code.icons })})],
@@ -595,7 +533,12 @@ ${userConfigSetup}export default defineConfig({
   // the overlap only adds memory.
   build: { concurrency: Math.min(8, availableParallelism()) },
   vite: {${viteCacheOption}
-    plugins: [${runtimeModulesPluginEntry}tailwindcss(), includeHmrPlugin(${JSON.stringify(`${context.outDir}/src/generated/includes.json`)}), prerenderDepsPlugin()],
+    plugins: [${runtimeModulesPluginEntry}tailwindcss(), includeHmrPlugin(${configPath(`${context.outDir}/src/generated/includes.json`, ejected)}), prerenderDepsPlugin()],
+    build: {${features.mermaid ? MERMAID_CHUNK_LIMIT : ""}
+      rolldownOptions: {
+        ${ROLLDOWN_ON_LOG},
+      },
+    },
     // Everything hydration can reach must be part of the dev dep optimizer's
     // FIRST run. The Vite root is the generated runtime, so user pages,
     // islands, and aliased components live outside it and are only crawled
@@ -641,12 +584,12 @@ ${userConfigSetup}export default defineConfig({
     },
     resolve: {
       alias: {
-        "blume:ask": ${JSON.stringify(askPath)},
-        "blume:examples": ${JSON.stringify(examplesPath)},
-        "blume:examples-theme": ${JSON.stringify(examplesThemePath)},
-        "blume:features": ${JSON.stringify(featuresPath)},
-        "blume:search-client": ${JSON.stringify(searchClientPath)},
-        "blume:theme": ${JSON.stringify(themePath)},${runtimeModuleAliasLines}${userAliasLines}
+        "blume:ask": ${configPath(askPath, ejected)},
+        "blume:examples": ${configPath(examplesPath, ejected)},
+        "blume:examples-theme": ${configPath(examplesThemePath, ejected)},
+        "blume:features": ${configPath(featuresPath, ejected)},
+        "blume:search-client": ${configPath(searchClientPath, ejected)},
+        "blume:theme": ${configPath(themePath, ejected)},${runtimeModuleAliasLines}${userAliasLines}
       },
     },
     server: {
@@ -660,16 +603,17 @@ ${userConfigSetup}export default defineConfig({
 };
 var stagedContentDir = (outDir) => join2(outDir, "content");
 var runtimeDirWithin = (base, outDir) => {
-  const rel = relative(base, outDir);
-  return rel && !rel.startsWith("..") && !isAbsolute(rel) ? rel : null;
+  const rel = relative2(base, outDir);
+  return rel && !rel.startsWith("..") && !isAbsolute2(rel) ? rel : null;
 };
-var astroGlobBase = (base) => isAbsolute(base) ? pathToFileURL(base).href : base;
+var astroGlobBase = (base) => isAbsolute2(base) ? pathToFileURL(base).href : base;
 var contentConfigTemplate = (options) => {
   const { context, config } = options;
   const stagedBase = options.stagedBase ?? stagedContentDir(context.outDir);
-  const collectionBase = options.collection?.base ?? context.contentRoot;
-  const includeGlobs = options.collection?.include ?? config.content.include;
-  const excludeGlobs = options.collection?.exclude ?? config.content.exclude;
+  const collection = options.collection ?? resolveDocsCollection(config, context.root);
+  const collectionBase = collection.base;
+  const includeGlobs = collection.include;
+  const excludeGlobs = collection.exclude;
   const outDirRel = runtimeDirWithin(collectionBase, context.outDir);
   const outDirIgnore = outDirRel ? [`!${outDirRel}/**`] : [];
   const filesystem = options.filesystem ?? true;
@@ -728,47 +672,20 @@ export const OPTIONS: APIRoute = ({ request }) =>
   preflightResponse(request, ALLOWED_ORIGINS);
 `
 } : { close: "};", imports: [], open: "async ({ request }) => {", setup: "" };
-var askEndpointTemplate = (backend, grounded, options) => {
-  const { instructions, reasoning, retrieval } = options ?? {};
+var ASK_BODY_LIMIT_BYTES = 65536;
+var askEndpointTemplate = (backend, options) => {
+  const { instructions, retrieval } = options ?? {};
+  const { grounded } = backend;
   const fallbackPrompt = instructions ? `${ASK_FALLBACK_PROMPT}
 
 ${instructions}` : ASK_FALLBACK_PROMPT;
   const imports = [
     'import type { APIRoute } from "astro";',
     'import { getSecret } from "astro:env/server";',
-    backend.kind === "gateway" ? 'import { createGateway, streamText } from "ai";' : 'import { streamText } from "ai";'
+    'import { readCappedText } from "blume/core/request-body.ts";',
+    ...backend.template.imports
   ];
-  let setup = "";
-  let modelExpr = JSON.stringify(backend.model);
-  const headersField = backend.headers ? `
-  headers: ${JSON.stringify(backend.headers)},` : "";
-  if (backend.kind === "gateway") {
-    setup = `
-const gateway = createGateway({
-  apiKey: getSecret("AI_GATEWAY_API_KEY"),${headersField}
-});
-`;
-    modelExpr = `gateway(${JSON.stringify(backend.model)})`;
-  } else if (backend.kind === "openrouter") {
-    imports.push('import { createOpenRouter } from "@openrouter/ai-sdk-provider";');
-    setup = `
-const openrouter = createOpenRouter({
-  apiKey: getSecret(${JSON.stringify(backend.apiKeyEnv)}),${headersField}
-});
-`;
-    const settings = reasoning ? `, { reasoning: { effort: ${JSON.stringify(reasoning)} } }` : "";
-    modelExpr = `openrouter(${JSON.stringify(backend.model)}${settings})`;
-  } else if (backend.kind === "openai-compatible") {
-    imports.push('import { createOpenAICompatible } from "@ai-sdk/openai-compatible";');
-    setup = `
-const provider = createOpenAICompatible({
-  apiKey: getSecret(${JSON.stringify(backend.apiKeyEnv)}),
-  baseURL: ${JSON.stringify(backend.baseUrl)},${headersField}
-  name: ${JSON.stringify(backend.name)},
-});
-`;
-    modelExpr = `provider(${JSON.stringify(backend.model)})`;
-  }
+  let { setup } = backend.template;
   if (grounded) {
     imports.push('import { createAskContext } from "blume/ai/ask-context.ts";', 'import askData from "blume:ask-data";');
     const groundFields = [];
@@ -785,7 +702,18 @@ const ground = createAskContext(askData${groundOptions});
   }
   const cors = askCorsTemplate(options?.cors);
   imports.push(...cors.imports);
-  const validate = `  const body = await request.json().catch(() => null);
+  const validate = `  const text = await readCappedText(request, ${ASK_BODY_LIMIT_BYTES});
+  if (text === undefined) {
+    return new Response("Request too large: the body must be at most 64 KB.", {
+      status: 413,
+    });
+  }
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    body = null;
+  }
   const raw = body?.messages;
   const valid =
     Array.isArray(raw) &&
@@ -810,30 +738,17 @@ const ground = createAskContext(askData${groundOptions});
     content: m.content,
     role: m.role,
   }));`;
-  const keyCheck = backend.kind === "gateway" ? `  // The AI Gateway authenticates with an API key or Vercel's OIDC token.
-  if (!(getSecret("AI_GATEWAY_API_KEY") || getSecret("VERCEL_OIDC_TOKEN"))) {
-    return new Response(
-      "Ask AI is not configured: set AI_GATEWAY_API_KEY (or deploy on Vercel with OIDC).",
-      { status: 500 }
-    );
-  }` : `  if (!getSecret(${JSON.stringify(backend.apiKeyEnv)})) {
-    return new Response(
-      ${JSON.stringify(`Ask AI is not configured: set ${backend.apiKeyEnv}.`)},
-      { status: 500 }
-    );
-  }`;
+  const { keyCheck } = backend.template;
   const onError = `      onError({ error }) {
         console.error("Ask AI provider error:", error);
       },`;
   const streamFields = [
-    `model: ${modelExpr}`,
+    `model: ${backend.template.model}`,
     grounded ? "instructions" : `instructions:
         ${JSON.stringify(fallbackPrompt)}`,
-    "messages"
+    "messages",
+    ...backend.template.fields
   ];
-  if (reasoning && backend.kind !== "openrouter") {
-    streamFields.push(`reasoning: ${JSON.stringify(reasoning)}`);
-  }
   const call = `    const result = streamText({
       ${streamFields.join(`,
       `)},
@@ -848,7 +763,9 @@ ${validate}
 ${keyCheck}
   try {
 ${stream}
-    return result.toTextStreamResponse();
+    return createTextStreamResponse({
+      stream: toTextStream({ stream: result.stream }),
+    });
   } catch {
     return new Response("Failed to generate a response.", { status: 500 });
   }
@@ -904,31 +821,9 @@ const indexUrl = joinBase(import.meta.env.BASE_URL, "blume-search.json");
 
 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)});
+var hostedSearchClient = (provider) => `${SEARCH_CLIENT_HEADER}${searchClientImport(provider.kind)}
+export const createSearch = () => create(${JSON.stringify(provider.options)});
 `;
-var hostedSearchOptions = (search) => {
-  switch (search.provider) {
-    case "algolia": {
-      return { module: "algolia", options: { ...search.algolia } };
-    }
-    case "orama-cloud": {
-      return {
-        module: "orama-cloud",
-        options: {
-          apiKey: search.oramaCloud?.apiKey,
-          endpoint: search.oramaCloud?.endpoint
-        }
-      };
-    }
-    case "typesense": {
-      return { module: "typesense", options: { ...search.typesense } };
-    }
-    default: {
-      return null;
-    }
-  }
-};
 var featuresTemplate = (features) => `// Generated by Blume. Do not edit.
 //
 // The client features this site uses. A feature no page needs stays out of
@@ -944,61 +839,86 @@ export const loadEpub:
   | null = ${features.epub ? '() => import("epub-gen-memory/bundle")' : "null"};
 `;
 var searchClientTemplate = (config) => {
-  const { search } = config;
-  if (search.provider === "orama" || search.provider === "flexsearch") {
-    const locale = search.provider === "orama" ? config.i18n?.defaultLocale : undefined;
-    return staticSearchClient(search.provider, locale);
-  }
-  const hosted = hostedSearchOptions(search);
-  if (hosted) {
-    return hostedSearchClient(hosted.module, hosted.options);
-  }
-  if (search.provider === "mixedbread") {
-    return `${SEARCH_CLIENT_HEADER}${searchClientImport("endpoint")}${SEARCH_BASE_IMPORT}
+  const { provider } = config.search;
+  switch (provider.mode) {
+    case "static": {
+      const locale = provider.kind === "orama" ? config.i18n?.defaultLocale : undefined;
+      return staticSearchClient(provider.kind, locale);
+    }
+    case "hosted": {
+      return hostedSearchClient(provider);
+    }
+    case "server": {
+      return `${SEARCH_CLIENT_HEADER}${searchClientImport("endpoint")}${SEARCH_BASE_IMPORT}
 const api = joinBase(import.meta.env.BASE_URL, "api/search");
 
 export const createSearch = () => create({ api });
 `;
-  }
-  if (search.provider === "pagefind") {
-    return `${SEARCH_CLIENT_HEADER}${searchClientImport("pagefind")}${SEARCH_BASE_IMPORT}
+    }
+    case "pagefind": {
+      return `${SEARCH_CLIENT_HEADER}${searchClientImport("pagefind")}${SEARCH_BASE_IMPORT}
 const url = joinBase(import.meta.env.BASE_URL, "pagefind/pagefind.js");
 
 export const createSearch = () => create({ url });
 `;
-  }
-  return `${SEARCH_CLIENT_HEADER}export const createSearch = () => () =>
+    }
+    default: {
+      return `${SEARCH_CLIENT_HEADER}export const createSearch = () => () =>
   Promise.resolve({ hits: [], sections: [] });
 `;
+    }
+  }
 };
-var mixedbreadSearchEndpointTemplate = (storeId) => `// Generated by Blume. Do not edit.
+var mixedbreadSearchEndpointTemplate = (options) => `// Generated by Blume. Do not edit.
 import type { APIRoute } from "astro";
 import { getSecret } from "astro:env/server";
 import Mixedbread from "@mixedbread/sdk";
+import { readCappedText } from "blume/core/request-body.ts";
 
 export const prerender = false;
 
 const client = new Mixedbread({ apiKey: getSecret("MIXEDBREAD_API_KEY") ?? "" });
-const STORE_ID = ${JSON.stringify(storeId)};
+const OPTIONS = ${JSON.stringify(options)};
+// Every option besides the store reaches the search call verbatim.
+const { storeId: STORE_ID, ...SEARCH_OPTIONS } = OPTIONS;
 
 export const POST: APIRoute = async ({ request }) => {
+  // A search body is one short query: read it under a 16 KB cap, so a
+  // self-hosted server never buffers an arbitrarily large POST first.
+  const text = await readCappedText(request, 16_384);
+  if (text === undefined) {
+    return new Response("Request too large: the body must be at most 16 KB.", {
+      status: 413,
+    });
+  }
   // The endpoint is public: a malformed body must 200-empty, not 500.
-  const body = await request.json().catch(() => null);
+  let body = null;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    body = null;
+  }
   const query = body?.query;
   if (!query || typeof query !== "string") {
     return new Response("[]", {
       headers: { "Content-Type": "application/json" },
     });
   }
+  // \`top_k\` defaults to 8 unless an option sets it; the query and store
+  // always come from the request and \`storeId\`.
   const response = await client.stores.search({
+    top_k: 8,
+    ...SEARCH_OPTIONS,
     query,
     store_identifiers: [STORE_ID],
-    top_k: 8,
   });
   const hits = (response.data ?? []).map((chunk) => {
     const meta = chunk.generated_metadata ?? {};
+    // Only a text chunk carries \`text\`; image, audio, and video chunks fall
+    // back to the excerpt the store generated for them.
+    const text = "text" in chunk ? chunk.text : undefined;
     return {
-      excerpt: chunk.text ?? meta.excerpt ?? "",
+      excerpt: text ?? meta.excerpt ?? "",
       title: meta.title ?? chunk.filename ?? "",
       url: meta.url ?? "",
     };
@@ -1114,9 +1034,15 @@ export const GET: APIRoute = async ({ params }) => {
     return new Response(null, { status: 404 });
   }
   const body = await readFile(path);
-  return new Response(new Uint8Array(body), {
-    headers: { "Content-Type": contentType(path) },
-  });
+  const type = contentType(path);
+  // An SVG opened directly is a document that can run script; the sandbox
+  // keeps an uploaded one inert on the docs origin. Static hosts get the same
+  // header from the build's header rules.
+  const headers: Record<string, string> =
+    type === "image/svg+xml"
+      ? { "Content-Security-Policy": ${JSON.stringify(SVG_ASSET_POLICY)}, "Content-Type": type }
+      : { "Content-Type": type };
+  return new Response(new Uint8Array(body), { headers });
 };
 `;
 var mcpPageFile = (route) => `${trimChar(route, "/")}.ts`;
@@ -1193,7 +1119,9 @@ export function getStaticPaths() {
   return navVariants(data, hiddenDefaultLocale(data.config.i18n)).flatMap(
     ({ locale, navigation, version }) =>
       [...navGroupIds(navigation.sidebar)]
-        .filter(([node]) => (node.display ?? "flat") !== "flat")
+        .filter(
+          ([node]) => node.kind === "group" && (node.display ?? "flat") !== "flat"
+        )
         .map(([, id]) => ({ params: { id, locale, version } }))
   );
 }
@@ -1412,8 +1340,7 @@ import LocaleLinks from "blume/components/layout/LocaleLinks.astro";
 import ApiOverview from "blume/components/openapi/ApiOverview.astro";
 import ApiTagOperations from "blume/components/openapi/ApiTagOperations.astro";
 import Operation from "blume/components/openapi/Operation.astro";
-${mathImport}import { mdxComponents as userMdx, layoutOverrides } from "../generated/components.ts";
-import { islandComponents } from "../generated/islands.ts";`,
+${mathImport}import { mdxComponents as userMdx, layoutOverrides } from "../generated/components.ts";`,
     map: `{
   Accordion,
   AccordionItem,
@@ -1449,8 +1376,7 @@ import { islandComponents } from "../generated/islands.ts";`,
   TypeTable,
   Visibility,
   YouTube,
-  ${mathEntry}...islandComponents,
-  ...userMdx,
+  ${mathEntry}...userMdx,
 }`
   };
 };
@@ -1492,6 +1418,7 @@ export function getStaticPaths() {
       indexable: route.indexable,
       lastModified: route.lastModified,
       locale: route.locale,
+      monolingual: route.monolingual,
       route: route.path,
       title: route.title,
       version: route.version,
@@ -1500,7 +1427,7 @@ export function getStaticPaths() {
   }));
 }
 
-const { entryId, collection, route, title, indexable, editUrl, lastModified, locale, alternates, fallback, version, versionAlternates } = Astro.props;
+const { entryId, collection, route, title, indexable, editUrl, lastModified, locale, alternates, fallback, monolingual, version, versionAlternates } = Astro.props;
 const entry = await getEntry(collection as CollectionKey, entryId);
 if (!entry) {
   return new Response(null, { status: 404 });
@@ -1592,13 +1519,32 @@ const contentDir = i18n
 // hreflang URLs byte-match the sitemap's <loc> for the home page.
 const absolute = (path: string) => base + withBase(path);
 
+// A fallback page renders the fallback locale's page at this locale's URL, so
+// its canonical names the page it copies, and search engines never rank the
+// copy against the original.
+const fallbackSource =
+  fallback && i18n?.fallbackLocale
+    ? (alternates ?? []).find((alt) => alt.locale === i18n.fallbackLocale)
+    : undefined;
+// The page it copies, when that page is archived too, points on to the latest
+// docs; the copy names that final page directly, the fallback locale's
+// version of the latest one, so the canonical is never a chain.
+const fallbackLatest =
+  fallbackSource && archived && archived.canonical === "latest" && latestVersionAlt
+    ? (data.routes.find((entry) => entry.path === latestVersionAlt.path)?.alternates ?? []).find(
+        (alt) => alt.locale === i18n?.fallbackLocale
+      )
+    : undefined;
+const fallbackTarget = fallbackLatest ?? fallbackSource;
 // An archived page defaults its canonical to the same page in the latest docs
 // when that page still exists — search engines treat the live page as
 // authoritative without deindexing version-only content. A page's own
 // \`seo.canonical\` always wins, and \`canonical: "self"\` keeps the default.
 const canonical =
   seo.canonical ??
-  (archived && archived.canonical === "latest" && latestVersionAlt && base
+  (fallbackTarget && base
+    ? absolute(fallbackTarget.path)
+    : archived && archived.canonical === "latest" && latestVersionAlt && base
     ? absolute(latestVersionAlt.path)
     : base
       ? \`\${base}\${basedRoute === "/" ? "/" : encodeURI(basedRoute)}\`
@@ -1628,7 +1574,9 @@ const mountLocalized = (logical: string, codeArg: string) =>
 const logicalRoute = i18n
   ? stripLocale(stripBasePath(data.config.basePath, route), locale)
   : route;
-const localeSwitch = i18n
+// A page from a one-language source (GitHub Releases) gets no switcher: every
+// other locale would only repeat the same text.
+const localeSwitch = i18n && !monolingual
   ? i18n.locales.map((l) => {
       const alt = (alternates ?? []).find((x) => x.locale === l.code);
       return {
@@ -1725,6 +1673,7 @@ const LayoutComponent = resolveSlot(layoutOverrides.Layout, RootLayout);
   locale={htmlLang}
   dir={dir}
   contentDir={contentDir}
+  contentLocale={contentLocale}
   ui={ui}
   localeAlternates={localeAlternates}
   xDefault={xDefault}
@@ -1772,38 +1721,28 @@ var changelogIndexTemplate = (options) => {
   clientData={{ config: data.config, navigation: data.navigation, page: { route: "/changelog", title: pageTitle } }}` : "";
   const stagedSpread = options.staged ? `
   ...(await getCollection("staged")),` : "";
-  const { imports: componentImports, map: componentMap } = contentComponentsSource(options.mathEnabled);
   return `---
 // Generated by Blume. Do not edit.
-import { getCollection, render } from "astro:content";
+import { getCollection } from "astro:content";
 import RootLayout from "blume/components/layout/RootLayout.astro";
-import Update from "blume/components/content/Update.astro";
 import { withBase } from "blume/components/islands/base-path.ts";
 import { resolveSlot } from "blume/components/layout/overrides.ts";
 import { resolveDateFormatOptions } from "blume/core/date-format.ts";
-${componentImports}
+import { layoutOverrides } from "../generated/components.ts";
 import data from "blume:data";
 
-const Color = Object.assign(ColorRoot, { Item: ColorItem, Row: ColorRow });
-const Tree = Object.assign(TreeRoot, { File: TreeFile, Folder: TreeFolder });
-
 export const prerender = true;
 
-// Entry bodies are MDX rendered outside the catch-all, so they need the same
-// component map: a \`:::\` callout or \`<Steps>\` in a release note otherwise
-// throws "Expected component ... to be defined" at build time.
-const components = ${componentMap};
-
 const entryDate = (entry: {
   data: { date?: string | null; changelog?: { date?: string | null } | null };
 }) => entry.data.date ?? entry.data.changelog?.date ?? null;
 
-const toTime = (value: string | null | undefined) => {
+const parseDate = (value: string | null | undefined) => {
   if (!value) {
-    return 0;
+    return null;
   }
   const date = new Date(value);
-  return Number.isNaN(date.getTime()) ? 0 : date.getTime();
+  return Number.isNaN(date.getTime()) ? null : date;
 };
 
 // The changelog is an unlocalized route, so its chrome renders in the default
@@ -1818,34 +1757,45 @@ const htmlLang = i18n ? i18n.defaultLocale : "en";
 
 // Formatted in the same locale as the chrome, and with the configured
 // \`dateFormat\` (UTC by default), to match the per-page "last updated" stamp.
+// The year heads each group, so a row shows the rest of the date: a preset
+// style keeps its month wording, a component format simply drops the year.
 const dateFormatOptions = resolveDateFormatOptions(data.config.dateFormat);
-const formatDate = (value: string | null | undefined) => {
-  if (!value) {
-    return;
-  }
-  const date = new Date(value);
-  return Number.isNaN(date.getTime())
-    ? undefined
-    : new Intl.DateTimeFormat(htmlLang, dateFormatOptions).format(date);
-};
+const { dateStyle, year: _year, ...dateComponents } = dateFormatOptions;
+const rowDateFormat: Intl.DateTimeFormatOptions = dateStyle
+  ? {
+      ...dateComponents,
+      day: "numeric",
+      month: dateStyle === "medium" ? "short" : "long",
+    }
+  : dateComponents;
+const formatRowDate = (date: Date) =>
+  new Intl.DateTimeFormat(htmlLang, rowDateFormat).format(date);
+const formatYear = (date: Date) =>
+  new Intl.DateTimeFormat(htmlLang, {
+    timeZone: dateFormatOptions.timeZone,
+    year: "numeric",
+  }).format(date);
 
 const slugify = (text: string) =>
   text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") ||
   "update";
 
-// The major of a version's embedded semver (\`1.2.3\` -> 1, \`pkg@2.0.0\` -> 2), or
-// null when there is no full major.minor.patch to key on. Drives the changelog's
-// group-by-major pagination, so it tolerates the scoped tags monorepos publish.
-const majorVersion = (version: string | null | undefined) => {
-  const match = /(\\d+)\\.\\d+\\.\\d+/.exec(String(version ?? ""));
-  return match ? Number(match[1]) : null;
-};
-
-// Map each entry to its own generated page so the timeline heading can deep-link
-// to it. The collection entry id matches the route manifest's \`entryId\`.
-const routeByEntry = new Map(
-  data.routes.map((route) => [route.entryId, route.path])
-);
+// Map each entry to its own generated page so the row can link to it. The
+// collection entry id matches the route manifest's \`entryId\` — and under
+// i18n every locale serves a page for it (its translations plus fallback
+// copies of an untranslated one), all sharing that id, so a map over every
+// route would keep whichever locale came last: a Portuguese permalink on an
+// unlocalized index. Only the default locale's routes are kept, and an entry
+// is listed only when it has one, so a translated changelog file (a distinct
+// entry that lives under its own locale) does not add a second row for the
+// same release.
+const defaultLocale = i18n ? i18n.defaultLocale : null;
+const routeByEntry = new Map<string, string>();
+for (const route of data.routes) {
+  if (defaultLocale === null || route.locale === defaultLocale) {
+    routeByEntry.set(route.entryId, route.path);
+  }
+}
 
 const changelogEntries = [
   ...(await getCollection("docs")),${stagedSpread}
@@ -1854,35 +1804,37 @@ const changelogEntries = [
     (entry) =>
       entry.data.type === "changelog" &&
       !entry.data.draft &&
-      !entry.data.sidebar?.hidden
+      !entry.data.sidebar?.hidden &&
+      (defaultLocale === null || routeByEntry.has(entry.id))
   )
-  .toSorted((a, b) => toTime(entryDate(b)) - toTime(entryDate(a)));
-
-const items = await Promise.all(
-  changelogEntries.map(async (entry) => {
-    const label =
-      entry.data.title ??
-      (entry.data.changelog?.version
-        ? "v" + entry.data.changelog.version
-        : "Update");
-    return {
-      Content: (await render(entry)).Content,
-      date: formatDate(entryDate(entry)),
-      href: routeByEntry.get(entry.id) ?? undefined,
-      id: slugify(label),
-      label,
-      major: majorVersion(entry.data.changelog?.version),
-      tags: entry.data.changelog?.category
-        ? [entry.data.changelog.category]
-        : [],
-    };
-  })
-);
+  .toSorted(
+    (a, b) =>
+      (parseDate(entryDate(b))?.getTime() ?? 0) -
+      (parseDate(entryDate(a))?.getTime() ?? 0)
+  );
+
+const items = changelogEntries.map((entry) => {
+  const label =
+    entry.data.title ??
+    (entry.data.changelog?.version
+      ? "v" + entry.data.changelog.version
+      : "Update");
+  const date = parseDate(entryDate(entry));
+  const route = routeByEntry.get(entry.id);
+  return {
+    date: date ? formatRowDate(date) : null,
+    dateTime: date ? date.toISOString().slice(0, 10) : null,
+    href: route ? withBase(route) : null,
+    id: slugify(label),
+    label,
+    tag: entry.data.changelog?.category ?? null,
+    year: date ? formatYear(date) : null,
+  };
+});
 
 // Repeated labels slug to the same id (e.g. two entries with neither a title
 // nor a version both falling back to "update"); suffix the later ones -2, -3,
-// ... so every heading deep-links to its own entry. The first keeps the plain
-// slug, and the rendered ids stay in lockstep with the \`headings\` list below.
+// ... so every row keeps its own hash anchor. The first keeps the plain slug.
 const seenIds = new Set();
 for (const item of items) {
   let uniqueId = item.id;
@@ -1893,26 +1845,18 @@ for (const item of items) {
   item.id = uniqueId;
 }
 
-// A changelog is semver-paginated only when every visible release parses as
-// semver and they span more than one major line. Older majors then collapse
-// into groups the reader reveals one at a time; otherwise the timeline is flat.
-const majors = items.every((item) => item.major !== null)
-  ? [...new Set(items.map((item) => item.major))]
-      .filter((major): major is number => major !== null)
-      .toSorted((a, b) => b - a)
-  : [];
-const paginate = majors.length > 1;
-const majorGroups = majors.map((major) => ({
-  items: items.filter((item) => item.major === major),
-  label: major + ".x",
-  major,
-}));
-
-const headings = items.map((item) => ({
-  depth: 2,
-  slug: item.id,
-  text: item.label,
-}));
+// Consecutive releases from the same year share a group, so the list reads as
+// a year rail beside the rows; undated entries (sorted last) form a final
+// group with no year label.
+const groups: { items: typeof items; year: string | null }[] = [];
+for (const item of items) {
+  const last = groups[groups.length - 1];
+  if (last && last.year === item.year) {
+    last.items.push(item);
+  } else {
+    groups.push({ items: [item], year: item.year });
+  }
+}
 
 const base = data.config.site ? data.config.site.replace(/\\/$/, "") : null;
 // The canonical URL carries the deployment base (the page is served under it),
@@ -1926,9 +1870,9 @@ const canonical = base ? base + basedRoute : null;
 const ogPath = data.config.og.enabled ? withBase("/og/changelog.png") : null;
 const ogImage = ogPath && base ? base + ogPath : ogPath;
 
-// The page chrome (h1, title, description) comes from the same translatable
-// \`changelog\` group as the reveal button; optional chaining tolerates a
-// not-yet-regenerated data snapshot from before these keys existed.
+// The page chrome (h1, title, description) comes from the translatable
+// \`changelog\` group; optional chaining tolerates a not-yet-regenerated data
+// snapshot from before these keys existed.
 const changelogTitle = data.ui.changelog?.title ?? "Changelog";
 const changelogDescription =
   data.ui.changelog?.description ??
@@ -1961,7 +1905,7 @@ const LayoutComponent = resolveSlot(layoutOverrides.Layout, RootLayout);
     description: changelogDescription,
     route: "/changelog",
   }}
-  headings={headings}
+  headings={[]}
   toc={data.config.toc}
   contentLayout="bare"
   themeMode={data.config.theme.mode}
@@ -1982,56 +1926,52 @@ const LayoutComponent = resolveSlot(layoutOverrides.Layout, RootLayout);
   structuredDataEnabled={data.config.structuredData}
 >
   <h1>{changelogTitle}</h1>
+  <p class="text-lg text-muted-foreground">{changelogDescription}</p>
   {
     items.length === 0 ? (
       <p>No changelog entries yet.</p>
-    ) : paginate ? (
-      <blume-changelog
-        class="not-prose mt-8 block"
-        data-i18n-more={data.ui.changelog?.showReleases}
-      >
-        {majorGroups[0].items.map(({ Content, href, id, label, date, tags }) => (
-          <Update description={date} href={href} id={id} label={label} tags={tags}>
-            <Content components={components} />
-          </Update>
-        ))}
-        {majorGroups.slice(1).map((group) => (
+    ) : (
+      <div class="not-prose mt-10 divide-y divide-border border-border border-y">
+        {groups.map((group) => (
           <section
-            aria-label={group.label + " releases"}
-            data-changelog-label={group.label}
-            data-changelog-major={group.major}
+            aria-label={group.year ?? undefined}
+            class="grid md:grid-cols-[6rem_minmax(0,1fr)] md:gap-x-8"
           >
-            {group.items.map(({ Content, href, id, label, date, tags }) => (
-              <Update description={date} href={href} id={id} label={label} tags={tags}>
-                <Content components={components} />
-              </Update>
-            ))}
+            <h2 class="mt-0! pt-3! font-medium! text-muted-foreground text-sm! leading-5! tabular-nums max-md:pb-1">
+              {group.year}
+            </h2>
+            <ul class="m-0! list-none divide-y divide-border p-0!">
+              {group.items.map((item) => (
+                <li class="m-0! p-0!" id={item.id}>
+                  <a
+                    class="group/release flex items-baseline gap-4 py-3 no-underline! hover:no-underline!"
+                    href={item.href ?? "#" + item.id}
+                  >
+                    <span class="min-w-0 flex-1 font-medium text-foreground text-sm transition-colors group-hover/release:text-accent">
+                      {item.label}
+                    </span>
+                    {item.tag && (
+                      <span class="shrink-0 rounded-full bg-muted px-2 py-0.5 font-medium text-[0.65rem] text-muted-foreground">
+                        {item.tag}
+                      </span>
+                    )}
+                    {item.date && (
+                      <time
+                        class="shrink-0 font-mono text-muted-foreground text-xs tabular-nums"
+                        datetime={item.dateTime}
+                      >
+                        {item.date}
+                      </time>
+                    )}
+                  </a>
+                </li>
+              ))}
+            </ul>
           </section>
         ))}
-        <div class="mt-10 flex justify-center">
-          <button
-            class="inline-flex items-center gap-2 rounded-full border border-border bg-background px-4 py-2 font-medium text-muted-foreground text-sm transition-colors hover:bg-muted hover:text-foreground"
-            data-changelog-more
-            hidden
-            type="button"
-          >
-            Show older releases
-          </button>
-        </div>
-      </blume-changelog>
-    ) : (
-      <div class="not-prose mt-8">
-        {items.map(({ Content, href, id, label, date, tags }) => (
-          <Update description={date} href={href} id={id} label={label} tags={tags}>
-            <Content components={components} />
-          </Update>
-        ))}
       </div>
     )
   }
-  <script>
-    import "blume/components/content/changelog-element.ts";
-  </script>
 </LayoutComponent>
 `;
 };
@@ -2059,7 +1999,7 @@ const htmlLang = i18n ? i18n.defaultLocale : "en";
 // Recovery links, so a reader — or an agent that followed a stale URL — can
 // get back on track without guessing: every top-level section, then the
 // machine-readable indexes the build emits (the sitemap only exists with a
-// \`deployment.site\`; llms.txt only when \`ai.llmsTxt\` is on). Tabs link to
+// \`deployment.site\`; llms.txt only when \`agents.llmsTxt\` is on). Tabs link to
 // their resolved target when the section has no index page of its own.
 const suggestions = [
   ...data.navigation.tabs.map((tab) => ({
@@ -2073,6 +2013,31 @@ const suggestions = [
     ? [{ href: withBase("/llms.txt"), label: nf.llms }]
     : []),
 ];
+
+// Every host serves this one page for any missing URL, so a reader who
+// mistyped \`/ar/…\` would get the default locale's message. The other locales'
+// copy rides along, and the script below swaps it in when the URL's first
+// segment names one of them — the message, its language and direction, the
+// tab title, and the home link (to that locale's root).
+const localized = Object.fromEntries(
+  (i18n?.locales ?? [])
+    .filter((l) => l.code !== i18n?.defaultLocale && data.uiByLocale[l.code])
+    .map((l) => {
+      const strings = data.uiByLocale[l.code].notFound;
+      return [
+        l.code,
+        {
+          description: strings.description,
+          dir: l.dir ?? "ltr",
+          home: strings.home,
+          homeHref: withBase("/" + l.code),
+          suggestions: strings.suggestions,
+          title: strings.title,
+        },
+      ];
+    })
+);
+const localizedJson = JSON.stringify(localized).replaceAll("<", "\\\\u003c");
 ---
 
 <PageLayout
@@ -2094,6 +2059,8 @@ const suggestions = [
 >
   <div
     class="mx-auto grid w-full max-w-5xl gap-12 px-6 py-20 sm:py-28 md:grid-cols-[3fr_2fr] md:gap-16 lg:gap-24 lg:py-36"
+    data-base={withBase("/")}
+    data-blume-not-found
   >
     <div class="flex flex-col items-start">
       <p
@@ -2103,24 +2070,26 @@ const suggestions = [
       </p>
       <h1
         class="mt-4 text-balance text-4xl font-semibold tracking-tight text-foreground sm:text-5xl"
+        data-nf="title"
       >
         {nf.title}
       </h1>
-      <p class="mt-4 max-w-md text-pretty text-lg text-muted-foreground">
+      <p class="mt-4 max-w-md text-pretty text-lg text-muted-foreground" data-nf="description">
         {nf.description}
       </p>
       <a
         class="mt-8 inline-flex items-center gap-1.5 rounded-full bg-accent py-2 pe-4 ps-3.5 text-sm font-medium text-accent-foreground transition-opacity hover:opacity-90"
+        data-nf-home
         href={withBase("/")}
       >
         <Icon class="rtl:-scale-x-100" name="arrow-left" size={14} />
-        {nf.home}
+        <span data-nf="home">{nf.home}</span>
       </a>
     </div>
     {
       suggestions.length > 0 && (
-        <nav aria-label={nf.suggestions} class="md:border-s md:border-border md:ps-12 lg:ps-16">
-          <h2 class="text-xs font-medium uppercase tracking-widest text-muted-foreground">
+        <nav aria-label={nf.suggestions} class="md:border-s md:border-border md:ps-12 lg:ps-16" data-nf-suggestions>
+          <h2 class="text-xs font-medium uppercase tracking-widest text-muted-foreground" data-nf="suggestions">
             {nf.suggestions}
           </h2>
           <ul class="mt-4 divide-y divide-border border-y border-border">
@@ -2144,6 +2113,37 @@ const suggestions = [
       )
     }
   </div>
+  <script id="blume-not-found-locales" is:inline type="application/json" set:html={localizedJson} />
+  <script is:inline>
+    (() => {
+      const apply = () => {
+        const root = document.querySelector("[data-blume-not-found]");
+        const source = document.getElementById("blume-not-found-locales");
+        if (!root || !source) {
+          return;
+        }
+        const base = root.getAttribute("data-base") || "/";
+        const path = location.pathname.startsWith(base)
+          ? location.pathname.slice(base.length)
+          : location.pathname.replace(/^\\/+/, "");
+        const code = path.split("/")[0];
+        const entry = JSON.parse(source.textContent || "{}")[code];
+        if (!entry) {
+          return;
+        }
+        root.setAttribute("lang", code);
+        root.setAttribute("dir", entry.dir);
+        for (const el of root.querySelectorAll("[data-nf]")) {
+          el.textContent = entry[el.getAttribute("data-nf")];
+        }
+        root.querySelector("[data-nf-home]")?.setAttribute("href", entry.homeHref);
+        root.querySelector("[data-nf-suggestions]")?.setAttribute("aria-label", entry.suggestions);
+        document.title = entry.title;
+      };
+      apply();
+      document.addEventListener("astro:page-load", apply);
+    })();
+  </script>
 </PageLayout>
 `;
 var notFoundMarkdownTemplate = () => `// Generated by Blume. Do not edit. Override by adding \`pages/404.astro\`.
@@ -2312,37 +2312,6 @@ const context = ${JSON.stringify(context)};
 
 export const ALL: APIRoute = ({ request }) => apiNotFoundResponse(request, context);
 `;
-var islandDirective = (spec) => spec.client === "only" ? `client:only="${spec.framework}"` : `client:${spec.client}`;
-var wrapperPropsType = (name) => `type Props = typeof ${name} extends (
-  props: infer P extends object,
-  ...rest: never[]
-) => unknown
-  ? P
-  : Record<string, unknown>;`;
-var islandWrapperTemplate = (spec) => `---
-// Generated by Blume. Do not edit.
-import Island from ${JSON.stringify(spec.file)};
-${wrapperPropsType("Island")}
----
-<Island ${islandDirective(spec)} {...Astro.props}><slot /></Island>
-`;
-var islandMapTemplate = (specs) => {
-  if (specs.length === 0) {
-    return `// Generated by Blume. Do not edit.
-export const islandComponents = {};
-`;
-  }
-  const imports = specs.map((spec, index) => `import I${index} from "./islands/${spec.name}.astro";`).join(`
-`);
-  const entries = specs.map((spec, index) => `  ${spec.name}: I${index},`).join(`
-`);
-  return `// Generated by Blume. Do not edit.
-${imports}
-export const islandComponents = {
-${entries}
-};
-`;
-};
 var exampleDirective = (spec) => {
   if (spec.framework === "astro" || !spec.client) {
     return "";
@@ -2350,9 +2319,9 @@ var exampleDirective = (spec) => {
   return spec.client === "only" ? `client:only="${spec.framework}" ` : `client:${spec.client} `;
 };
 var exampleSlug = (path) => path.replaceAll(/[^a-zA-Z0-9]/gu, (char) => `_${(char.codePointAt(0) ?? 0).toString(16)}_`);
-var exampleWrapperTemplate = (spec) => `---
+var exampleWrapperTemplate = (spec, fromDir) => `---
 // Generated by Blume. Do not edit.
-import Example from ${JSON.stringify(spec.file)};
+import Example from ${JSON.stringify(importSpecifier(spec.file, fromDir))};
 ${wrapperPropsType("Example")}
 ---
 <Example ${exampleDirective(spec)}{...Astro.props}><slot /></Example>
@@ -2496,7 +2465,7 @@ var runtimeTsconfigTemplate = () => `${JSON.stringify({
 }, null, 2)}
 `;
 
-export { ADAPTER_IGNORE_DIRS, servesClientSubdir, deployStaticDir, surfaceAdapterOutput, resolveAskBackend, askBackendRuntimeDep, buildHomeLinkHeader, platformRedirects, publishRuntimeModules, runtimeDependencies, astroConfigTemplate, stagedContentDir, contentConfigTemplate, askEndpointTemplate, askComponentTemplate, searchEndpointTemplate, featuresTemplate, searchClientTemplate, mixedbreadSearchEndpointTemplate, rawMarkdownEndpointTemplate, contentAssetsEndpointTemplate, mcpPageFile, mcpEndpointTemplate, playgroundProxyTemplate, staticJsonEndpointTemplate, rssEndpointTemplate, navFragmentTemplate, ogEndpointTemplate, scalarReferenceTemplate, catchAllPageTemplate, changelogIndexTemplate, notFoundPageTemplate, notFoundMarkdownTemplate, notFoundJsonTemplate, apiPagesIndexTemplate, apiPageTemplate, apiNavigationTemplate, apiSearchTemplate, apiNotFoundTemplate, islandWrapperTemplate, islandMapTemplate, exampleSlug, exampleWrapperTemplate, examplesRouteBase, exampleMapTemplate, examplesPageTemplate, runtimePackageTemplate, runtimeTsconfigTemplate };
+export { planComponentSlots, publishRuntimeModules, runtimeDependencies, EJECTED_CONFIG_HEADER, astroConfigTemplate, stagedContentDir, contentConfigTemplate, askEndpointTemplate, askComponentTemplate, searchEndpointTemplate, featuresTemplate, searchClientTemplate, mixedbreadSearchEndpointTemplate, rawMarkdownEndpointTemplate, contentAssetsEndpointTemplate, mcpPageFile, mcpEndpointTemplate, playgroundProxyTemplate, staticJsonEndpointTemplate, rssEndpointTemplate, navFragmentTemplate, ogEndpointTemplate, scalarReferenceTemplate, catchAllPageTemplate, changelogIndexTemplate, notFoundPageTemplate, notFoundMarkdownTemplate, notFoundJsonTemplate, apiPagesIndexTemplate, apiPageTemplate, apiNavigationTemplate, apiSearchTemplate, apiNotFoundTemplate, exampleSlug, exampleWrapperTemplate, examplesRouteBase, exampleMapTemplate, examplesPageTemplate, runtimePackageTemplate, runtimeTsconfigTemplate };
 
-//# debugId=53365D3EDA449FFB64756E2164756E21
-//# sourceMappingURL=chunk-ejjx8znq.js.map
+//# debugId=9E2BF1A2CC0BBFF264756E2164756E21
+//# sourceMappingURL=chunk-mnqj32sj.js.map