blume 1.6.5 → 1.7.0

package/dist/cli/chunk-agy5rzxy.js

@@ -0,0 +1,2453 @@
+#!/usr/bin/env node
+import {
+  API_CATALOG_PATH,
+  OPENAPI_PATH,
+  hasApiCatalog
+} from "./chunk-j6pxe0dt.js";
+import {
+  searchProviderMeta
+} from "./chunk-wd27zjcz.js";
+import {
+  BLUME_IGNORE_DIRS,
+  TOC_HIDDEN_KEY
+} from "./chunk-s102bysw.js";
+import {
+  buildFontEntries,
+  fontLocaleCodes,
+  hasScalarReferences
+} from "./chunk-xv91q4nm.js";
+import {
+  normalizeBasePath,
+  trimChar,
+  withBasePath,
+  withComposedBasePath
+} from "./chunk-27gtm2ym.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 };
+  }
+  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"`);
+  }
+  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/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 resolveAskBackend = (ask) => {
+  const provider = ask?.provider ?? "gateway";
+  const model = ask?.model ?? DEFAULT_MODEL;
+  if (provider === "gateway") {
+    return { kind: "gateway", model };
+  }
+  const preset = ASK_PRESETS[provider];
+  const apiKeyEnv = ask?.apiKeyEnv ?? preset?.apiKeyEnv ?? "API_KEY";
+  if (provider === "openrouter") {
+    return { apiKeyEnv, kind: "openrouter", model };
+  }
+  return {
+    apiKeyEnv,
+    baseUrl: ask?.baseUrl ?? preset?.baseUrl ?? "",
+    kind: OPENAI_COMPATIBLE,
+    model,
+    name: preset?.name ?? OPENAI_COMPATIBLE
+  };
+};
+var askBackendRuntimeDep = (ask) => {
+  const provider = ask?.provider ?? "gateway";
+  if (provider === "gateway") {
+    return;
+  }
+  return ASK_PRESETS[provider]?.runtimeDep ?? OPENAI_COMPATIBLE_DEP;
+};
+
+// src/astro/runtime-modules.ts
+var RUNTIME_MODULE_FILES = new Map([
+  ["blume:ask-data", "ask-data.json"],
+  ["blume:content-assets", "content-assets.json"],
+  ["blume:data", "data.json"],
+  ["blume:mcp-data", "mcp-data.json"],
+  ["blume:openapi", "openapi.json"],
+  ["blume:raw-markdown", "raw-markdown.json"],
+  ["blume:rss", "rss.json"],
+  ["blume:search-index", "search.json"]
+]);
+var RUNTIME_MODULE_IDS = new Set(RUNTIME_MODULE_FILES.keys());
+var RESOLVED_PREFIX = "\x00";
+var REGISTRY_KEY = Symbol.for("blume.runtime-modules");
+var registry = () => {
+  const host = globalThis;
+  host[REGISTRY_KEY] ??= { modules: new Map, servers: new Set };
+  return host[REGISTRY_KEY];
+};
+var publishRuntimeModules = (modules) => {
+  const { modules: current, servers } = registry();
+  const changed = [];
+  for (const id of RUNTIME_MODULE_FILES.keys()) {
+    const next = modules.get(id);
+    if (current.get(id) === next) {
+      continue;
+    }
+    if (next === undefined) {
+      current.delete(id);
+    } else {
+      current.set(id, next);
+    }
+    changed.push(id);
+  }
+  if (changed.length === 0) {
+    return changed;
+  }
+  for (const server of servers) {
+    for (const id of changed) {
+      const mod = server.moduleGraph.getModuleById(`${RESOLVED_PREFIX}${id}`);
+      if (mod) {
+        server.moduleGraph.invalidateModule(mod);
+      }
+    }
+    server.ws.send({ type: "full-reload" });
+  }
+  return changed;
+};
+
+// src/astro/templates.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { dirname as dirname2, isAbsolute, join as join2, relative } from "pathe";
+var WORKSPACE_MARKERS = [
+  ".git",
+  "bun.lock",
+  "bun.lockb",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "pnpm-workspace.yaml",
+  "yarn.lock"
+];
+var hasWorkspacesField = (pkgPath) => {
+  if (!existsSync2(pkgPath)) {
+    return false;
+  }
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg.workspaces !== undefined;
+  } catch {
+    return false;
+  }
+};
+var hasWorkspaceMarker = (dir) => hasWorkspacesField(join2(dir, "package.json")) || WORKSPACE_MARKERS.some((marker) => existsSync2(join2(dir, marker)));
+var findWorkspaceRoot = (start) => {
+  let dir = start;
+  for (;; ) {
+    if (hasWorkspaceMarker(dir)) {
+      return dir;
+    }
+    const parent = dirname2(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)}`);
+  }
+  return `{ ${args.join(", ")} }`;
+};
+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"];
+  if (options.hasFonts) {
+    names.push("fontProviders");
+  }
+  return `import { ${names.join(", ")} } from "astro/config";`;
+};
+var runtimeDependencies = (options) => {
+  const { config, needsReact, needsSvelte, needsVue } = options;
+  const deps = ["@astrojs/mdx"];
+  if (needsReact) {
+    deps.push("@astrojs/react");
+  }
+  if (needsVue) {
+    deps.push("@astrojs/vue");
+  }
+  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);
+    }
+  }
+  const { deployment } = config;
+  if (deployment.output === "server" && deployment.adapter) {
+    const adapter = ADAPTER_IMPORTS[deployment.adapter];
+    if (adapter) {
+      deps.push(adapter);
+    }
+  }
+  return deps;
+};
+var RENDER_EXTERNAL_DEPS = [
+  "@astrojs/markdown-satteri",
+  "@pierre/diffs",
+  "@shikijs/transformers",
+  "@takumi-rs/core",
+  "@takumi-rs/helpers",
+  "@takumi-rs/wasm",
+  "github-slugger",
+  "katex",
+  "shiki",
+  "simple-icons",
+  "takumi-js",
+  "takumi-js/helpers",
+  "zod"
+];
+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) {
+    return { astro: "", vite: "" };
+  }
+  return {
+    astro: `
+  cacheDir: ${JSON.stringify(`${context.outDir}/.cache/astro`)},`,
+    vite: `
+    cacheDir: ${JSON.stringify(`${context.outDir}/.cache/vite`)},`
+  };
+};
+var reactIntegration = (compilerPath) => compilerPath ? `react({ babel: { plugins: [[${JSON.stringify(compilerPath)}, { target: "19" }]] }, ${REACT_EXCLUDE} })` : `react({ ${REACT_EXCLUDE} })`;
+var renderIntegrationBridge = (bridge) => {
+  if (!bridge) {
+    return {
+      configSourceMarker: "",
+      userConfigImports: "",
+      userConfigSetup: "",
+      userIntegrationSpread: ""
+    };
+  }
+  return {
+    configSourceMarker: bridge.sourceHash ? `// Blume config source SHA-256: ${bridge.sourceHash}
+` : "",
+    userConfigImports: `import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createModuleLoader } from "blume/core/load-module.ts";
+`,
+    userConfigSetup: `const loadBlumeConfig = createModuleLoader();
+const blumeConfig = await loadBlumeConfig(resolve(dirname(fileURLToPath(import.meta.url)), ${JSON.stringify(bridge.configFile)}));
+
+`,
+    userIntegrationSpread: ", ...(blumeConfig?.integrations ?? [])"
+  };
+};
+var renderImageOption = (config) => config.image.domains.length > 0 || config.image.remotePatterns.length > 0 ? `
+  image: ${JSON.stringify(config.image)},` : "";
+var ALL_CLIENT_FEATURES = { epub: true, mermaid: true };
+var resolveOptimizeDeps = (options) => {
+  const { context, features } = options;
+  const optimizeDepsEntries = [
+    ...context.pagesRoot ? [`${context.pagesRoot}/**/*.astro`] : [],
+    `${context.root}/islands/**/*.{jsx,svelte,tsx,vue}`,
+    ...[...new Set(Object.values(options.aliases ?? {}))].toSorted().map((dir) => `${dir}/**/*.{astro,jsx,svelte,tsx,vue}`)
+  ];
+  const optimizeDepsInclude = [
+    ...features.mermaid ? ["blume > mermaid"] : [],
+    ...features.epub ? ["blume > epub-gen-memory/bundle"] : [],
+    ...options.needsReact && options.reactCompilerPath ? ["react/compiler-runtime"] : []
+  ];
+  return { optimizeDepsEntries, optimizeDepsInclude };
+};
+var renderRuntimeModuleWiring = (generatedModulesDir) => {
+  if (generatedModulesDir === undefined) {
+    return {
+      aliasLines: "",
+      imports: ["runtimeModulesPlugin"],
+      pluginEntry: "runtimeModulesPlugin(), "
+    };
+  }
+  const aliasLines = [...RUNTIME_MODULE_FILES].map(([id, file]) => `
+        ${JSON.stringify(id)}: ${JSON.stringify(`${generatedModulesDir}/${file}`)},`).join("");
+  return { aliasLines, imports: [], pluginEntry: "" };
+};
+var blumeIntegrationOptions = (options) => options.ejected ? {
+  buildArtifactsRoot: ".",
+  contentRoutes: options.contentRoutes,
+  homeLinkHeader: buildHomeLinkHeader(options.config, options.contentRoutes) ?? undefined,
+  pages: options.pages
+} : { pages: options.pages };
+var astroConfigTemplate = (options) => {
+  const { context, config, needsReact, pages, themePath } = options;
+  const { astro: cacheOptions, vite: viteCacheOption } = runtimeCacheOptions(context, options.generatedModulesDir);
+  const {
+    askPath,
+    contentRoutes,
+    examplesPath,
+    examplesThemePath,
+    features = ALL_CLIENT_FEATURES,
+    featuresPath,
+    generatedModulesDir,
+    needsSvelte,
+    needsVue,
+    searchClientPath
+  } = options;
+  const {
+    aliasLines: runtimeModuleAliasLines,
+    imports: runtimeModuleImports,
+    pluginEntry: runtimeModulesPluginEntry
+  } = 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,
+    context,
+    features,
+    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 imageOption = renderImageOption(config);
+  const i18nOption = config.i18n ? `
+  i18n: ${JSON.stringify({
+    defaultLocale: config.i18n.defaultLocale,
+    locales: config.i18n.locales.map((locale) => locale.code),
+    routing: {
+      prefixDefaultLocale: !config.i18n.hideDefaultLocalePrefix
+    }
+  })},` : "";
+  const basedRedirects = applyBaseToAstroRedirects(config.redirects, config.basePath, deployment.base ?? "");
+  const redirectsOption = basedRedirects.length > 0 ? `
+  redirects: ${JSON.stringify(Object.fromEntries(basedRedirects.map((redirect) => [
+    redirect.from,
+    { destination: redirect.to, status: redirect.status }
+  ])))},` : "";
+  const fontEntries = buildFontEntries(config.theme.fonts, fontLocaleCodes(config.i18n));
+  const fontsOption = fontEntries.length ? `
+  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) => {
+    const face = {};
+    if (variant.weight !== undefined) {
+      face.weight = variant.weight;
+    }
+    if (variant.style !== undefined) {
+      face.style = variant.style;
+    }
+    return {
+      ...face,
+      src: [
+        isAbsolute(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(", ")}],` : "";
+  const defineConfigImport = astroConfigImportLine({
+    hasFonts: fontEntries.length > 0
+  });
+  const reactImport = needsReact ? `import react from "@astrojs/react";
+` : "";
+  const vueImport = needsVue ? `import vue from "@astrojs/vue";
+` : "";
+  const svelteImport = needsSvelte ? `import svelte from "@astrojs/svelte";
+` : "";
+  const blumeImports = [
+    "blumeIntegration",
+    "includeHmrPlugin",
+    "prerenderDepsPlugin",
+    ...runtimeModuleImports,
+    ...adapterOption.includes("withAdapterRoot") ? ["withAdapterRoot"] : []
+  ];
+  const blumeImport = `import { ${blumeImports.join(", ")} } from "blume/astro";
+`;
+  const twoslashTransformer = "blumeTwoslashTransformer(), ";
+  const deployBase = normalizeBasePath(deployment.base);
+  const integrations = [
+    `mdx({ processor: blumeMdxProcessor(${JSON.stringify({
+      basePath: config.basePath,
+      codeThemes: config.markdown.codeBlocks.theme,
+      contentRoot: options.contentRoot,
+      deployBase,
+      headingAnchors: config.markdown.headingAnchors
+    })}) })`
+  ];
+  if (needsReact) {
+    integrations.push(reactIntegration(options.reactCompilerPath));
+  }
+  if (needsVue) {
+    integrations.push("vue()");
+  }
+  if (needsSvelte) {
+    integrations.push("svelte()");
+  }
+  integrations.push(`blumeIntegration(${JSON.stringify(blumeIntegrationOptions({
+    config,
+    contentRoutes,
+    ejected: generatedModulesDir !== undefined,
+    pages
+  }))})`);
+  const {
+    configSourceMarker,
+    userConfigImports,
+    userConfigSetup,
+    userIntegrationSpread
+  } = renderIntegrationBridge(options.integrationBridge);
+  return `// Generated by Blume. Do not edit; this file is recreated on each run.
+${configSourceMarker}${userConfigImports}import { availableParallelism } from "node:os";
+${defineConfigImport}
+import mdx from "@astrojs/mdx";
+import tailwindcss from "@tailwindcss/vite";
+import { blumeMarkdownProcessor, blumeMdxProcessor, blumeShikiTransformers, blumeTwoslashTransformer } from "blume/markdown";
+${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))},
+  publicDir: ${JSON.stringify(`${context.root}/public`)},${cacheOptions}
+  output: ${JSON.stringify(deployment.output)},${adapterOption}${sessionOption}${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
+  })}),
+    shikiConfig: {
+      themes: {
+        light: ${JSON.stringify(config.markdown.codeBlocks.theme.light)},
+        dark: ${JSON.stringify(config.markdown.codeBlocks.theme.dark)},
+      },
+      defaultColor: false,
+      transformers: [${twoslashTransformer}...blumeShikiTransformers(${JSON.stringify({ icons: config.markdown.code.icons })})],
+    },
+  },
+  devToolbar: { enabled: false },
+  // One canonical URL per page: canonicals, the sitemap, and hreflang all use
+  // the slashless form, so the slashed spelling is not a second address. Astro
+  // applies this itself — its dev server answers a slashed URL with a 404 that
+  // names the setting, an on-demand route redirects — and the Vercel adapter
+  // turns it into the platform's 308 route, so the Build Output config needs
+  // no hand-spliced redirect (see deploy/vercel-negotiation.ts). Static hosts
+  // serve the \`index.html\` directory layout as they always did.
+  trailingSlash: "never",
+  // The layouts render Astro's <ClientRouter />, and its in-place swaps read
+  // from the prefetch cache — fetching every link on hover/viewport hides the
+  // request latency behind the user's intent, so most navigations swap
+  // instantly.
+  prefetch: { prefetchAll: true },
+  // Prerender several pages at once. Rendering is single-threaded, but a
+  // page's OG card renders on a native thread and its HTML is written
+  // asynchronously, so the main thread would otherwise idle behind each
+  // page's off-thread work. Capped at 8: the gain flattens there and beyond it
+  // 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()],
+    // 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
+    // when first requested — and \`react/compiler-runtime\` is Babel-injected,
+    // so no source scan can ever see it. A dependency discovered after
+    // hydration begins triggers a mid-session re-optimization whose new
+    // generation imports React through new \`?v=\` URLs; the browser then
+    // evaluates a second React copy and every island tears down with
+    // "Invalid hook call" (#157). \`entries\` points the startup scanner at
+    // the user's files (the scanner follows their imports, so their deps land
+    // in the initial optimization); the compiler runtime rides the include
+    // list because only the transform pipeline knows it exists.
+    //
+    // The mermaid/epub includes fix CJS interop instead: both lazy client-side
+    // imports land on CJS/UMD files (mermaid statically imports dayjs as CJS,
+    // epub-gen-memory's browser bundle is a browserified UMD) that break when
+    // served as raw ESM — mermaid throws on load and the EPUB export throws
+    // \`epub is not a function\`. They resolve through the \`blume\` package
+    // (they aren't direct deps of the generated project), so the nested
+    // \`blume > x\` form is required, and epub-gen-memory must name the
+    // \`/bundle\` subpath that is actually imported: optimizing the package
+    // root leaves that entry out. Production (Rollup) already handles the
+    // interop, so all of this only affects dev.
+    optimizeDeps: {
+      entries: ${JSON.stringify(optimizeDepsEntries)},
+      include: ${JSON.stringify(optimizeDepsInclude)},
+    },
+    // Blume's render-time deps are forced external on both build environments so
+    // native bindings resolve at runtime and isolated linkers don't bundle
+    // symlinked store copies (which would surface their children as unresolvable
+    // imports). See RENDER_EXTERNAL_DEPS / prerenderDepsPlugin.
+    //
+    // The SSR externals go through the legacy \`ssr.external\` key rather than
+    // \`environments.ssr\`: defining a user-owned \`environments.ssr\` block
+    // collides with the internal environment Astro 7 builds the server under and
+    // detaches the adapter's server entrypoint from the rolldown input, so the
+    // SSR entry is emitted as \`index.mjs\` instead of the \`entry.mjs\` the
+    // Vercel adapter's \`astro:build:done\` hook then fails to find. \`prerender\`
+    // is Astro-only and has no legacy equivalent, so it stays under \`environments\`.
+    ssr: { external: ${JSON.stringify(RENDER_EXTERNAL_DEPS)} },
+    environments: {
+      prerender: { resolve: { external: ${JSON.stringify(RENDER_EXTERNAL_DEPS)} } },
+    },
+    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}
+      },
+    },
+    server: {
+      fs: {
+        allow: ${JSON.stringify(fsAllow)},
+      },
+    },
+  },
+});
+`;
+};
+var stagedContentDir = (outDir) => join2(outDir, "content");
+var runtimeDirWithin = (base, outDir) => {
+  const rel = relative(base, outDir);
+  return rel && !rel.startsWith("..") && !isAbsolute(rel) ? rel : null;
+};
+var astroGlobBase = (base) => isAbsolute(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 outDirRel = runtimeDirWithin(collectionBase, context.outDir);
+  const outDirIgnore = outDirRel ? [`!${outDirRel}/**`] : [];
+  const filesystem = options.filesystem ?? true;
+  const docsPattern = filesystem ? [
+    ...includeGlobs,
+    ...(excludeGlobs ?? []).map((pattern) => `!${pattern}`),
+    ...BLUME_IGNORE_DIRS.flatMap((dir) => dir === ".blume" ? [] : [`!**/${dir}/**`]),
+    ...outDirIgnore
+  ] : [];
+  const stagedBlock = options.staged ? `
+const staged = defineCollection({
+  loader: glob({
+    pattern: ["**/*.{md,mdx}"],
+    base: ${JSON.stringify(astroGlobBase(stagedBase))},
+    generateId: ({ entry }) => entry,
+  }),
+  schema: pageCollectionSchema,
+});
+` : "";
+  return `// Generated by Blume. Do not edit.
+import { defineCollection } from "astro:content";
+import { glob } from "astro/loaders";
+import { withIncludeRefresh } from "blume/astro";
+import { pageCollectionSchema } from "blume/core/schema.ts";
+
+// withIncludeRefresh keeps <include>-bearing pages fresh: plain .md entries
+// are rendered at sync time and digest-cached on the page file alone, so a
+// partial edit (or a warm-cache rebuild after one) would serve stale HTML.
+//
+// pageCollectionSchema is the scan's page front-matter schema, so entry.data
+// is typed and normalized the same way; it passes custom keys through and
+// falls back to defaults for a page the scan already dropped as invalid.
+const docs = defineCollection({
+  loader: withIncludeRefresh(glob({
+    pattern: ${JSON.stringify(docsPattern)},
+    base: ${JSON.stringify(astroGlobBase(collectionBase))},
+    generateId: ({ entry }) => entry,
+  }), ${JSON.stringify(`${context.outDir}/src/generated/includes.json`)}),
+  schema: pageCollectionSchema,
+});
+${stagedBlock}
+export const collections = { docs${options.staged ? ", staged" : ""} };
+`;
+};
+var ASK_FALLBACK_PROMPT = "You are a helpful documentation assistant. Answer using the project's documentation.";
+var askEndpointTemplate = (backend, grounded, options) => {
+  const instructions = options?.instructions;
+  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";'
+  ];
+  let setup = "";
+  let modelExpr = JSON.stringify(backend.model);
+  if (backend.kind === "gateway") {
+    setup = `
+const gateway = createGateway({ apiKey: getSecret("AI_GATEWAY_API_KEY") });
+`;
+    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)}) });
+`;
+    modelExpr = `openrouter(${JSON.stringify(backend.model)})`;
+  } 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)},
+  name: ${JSON.stringify(backend.name)},
+});
+`;
+    modelExpr = `provider(${JSON.stringify(backend.model)})`;
+  }
+  if (grounded) {
+    imports.push('import { createAskContext } from "blume/ai/ask-context.ts";', 'import askData from "blume:ask-data";');
+    const groundFields = [];
+    if (instructions) {
+      groundFields.push(`instructions: ${JSON.stringify(instructions)}`);
+    }
+    if (options?.retrieval) {
+      groundFields.push(`retrieval: ${JSON.stringify(options.retrieval)}`);
+    }
+    const groundOptions = groundFields.length > 0 ? `, { ${groundFields.join(", ")} }` : "";
+    setup += `
+const ground = createAskContext(askData${groundOptions});
+`;
+  }
+  const validate = `  const body = await request.json().catch(() => null);
+  const raw = body?.messages;
+  const valid =
+    Array.isArray(raw) &&
+    raw.length > 0 &&
+    raw.length <= 40 &&
+    raw.every(
+      (m: unknown) =>
+        typeof m === "object" &&
+        m !== null &&
+        ("role" in m && (m.role === "user" || m.role === "assistant")) &&
+        ("content" in m && typeof m.content === "string")
+    ) &&
+    JSON.stringify(raw).length <= 24_000;
+  if (!valid) {
+    return new Response(
+      "Invalid request: send 1-40 user/assistant messages with string content.",
+      { status: 400 }
+    );
+  }
+  // Re-build the array so only role/content ever reach the model.
+  const messages = raw.map((m: { role: "user" | "assistant"; content: string }) => ({
+    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 onError = `      onError({ error }) {
+        console.error("Ask AI provider error:", error);
+      },`;
+  const stream = grounded ? `    const instructions =
+      (await ground(messages, body.page)) ??
+      ${JSON.stringify(fallbackPrompt)};
+    const result = streamText({
+      model: ${modelExpr},
+      instructions,
+      messages,
+${onError}
+    });` : `    const result = streamText({
+      model: ${modelExpr},
+      instructions:
+        ${JSON.stringify(fallbackPrompt)},
+      messages,
+${onError}
+    });`;
+  const handler = `export const POST: APIRoute = async ({ request }) => {
+${validate}
+${keyCheck}
+  try {
+${stream}
+    return result.toTextStreamResponse();
+  } catch {
+    return new Response("Failed to generate a response.", { status: 500 });
+  }
+};`;
+  return `// Generated by Blume. Do not edit.
+${imports.join(`
+`)}
+
+export const prerender = false;
+${setup}
+${handler}
+`;
+};
+var askComponentTemplate = (askEnabled) => askEnabled ? `---
+// Generated by Blume. Do not edit.
+import AskAI from "blume/components/islands/AskAI.astro";
+import data from "blume:data";
+
+const { strings } = Astro.props;
+---
+
+<AskAI
+  endpoint={data.config.ask?.endpoint ?? undefined}
+  strings={strings ?? data.ui.ask}
+  suggestions={data.config.ask?.suggestions ?? []}
+/>
+` : `---
+// Generated by Blume. Do not edit.
+// Ask AI is off (\`ai.ask.enabled\`), so the header's Ask trigger renders nothing.
+// Deliberately imports no React island, keeping the JSX renderer out of projects
+// that don't need it.
+---
+`;
+var searchEndpointTemplate = () => `// Generated by Blume. Do not edit.
+import documents from "blume:search-index";
+
+export const prerender = true;
+
+export function GET() {
+  return new Response(JSON.stringify(documents), {
+    headers: { "Content-Type": "application/json" },
+  });
+}
+`;
+var SEARCH_CLIENT_HEADER = `// Generated by Blume. Do not edit.
+`;
+var searchClientImport = (module) => `import { createSearch as create } from "blume/components/layout/search/${module}.ts";
+`;
+var SEARCH_BASE_IMPORT = `import { joinBase } from "blume/components/islands/base-path.ts";
+`;
+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${locale ? `, locale: ${JSON.stringify(locale)}` : ""} });
+`;
+var hostedSearchClient = (module, options) => `${SEARCH_CLIENT_HEADER}${searchClientImport(module)}
+export const createSearch = () => create(${JSON.stringify(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
+// the module graph entirely: its loader is null and its library never enters
+// the client bundle.
+
+/** Registers the <blume-mermaid> element; null when no page has a mermaid fence. */
+export const loadMermaid: (() => Promise<unknown>) | null = ${features.mermaid ? '() => import("blume/components/content/mermaid-element.ts")' : "null"};
+
+/** The EPUB generator's browser bundle; null when export.epub is off. */
+export const loadEpub:
+  | (() => Promise<typeof import("epub-gen-memory/bundle")>)
+  | 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 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}
+const url = joinBase(import.meta.env.BASE_URL, "pagefind/pagefind.js");
+
+export const createSearch = () => create({ url });
+`;
+  }
+  return `${SEARCH_CLIENT_HEADER}export const createSearch = () => () =>
+  Promise.resolve({ hits: [], sections: [] });
+`;
+};
+var mixedbreadSearchEndpointTemplate = (storeId) => `// Generated by Blume. Do not edit.
+import type { APIRoute } from "astro";
+import { getSecret } from "astro:env/server";
+import Mixedbread from "@mixedbread/sdk";
+
+export const prerender = false;
+
+const client = new Mixedbread({ apiKey: getSecret("MIXEDBREAD_API_KEY") ?? "" });
+const STORE_ID = ${JSON.stringify(storeId)};
+
+export const POST: APIRoute = async ({ request }) => {
+  // The endpoint is public: a malformed body must 200-empty, not 500.
+  const body = await request.json().catch(() => null);
+  const query = body?.query;
+  if (!query || typeof query !== "string") {
+    return new Response("[]", {
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+  const response = await client.stores.search({
+    query,
+    store_identifiers: [STORE_ID],
+    top_k: 8,
+  });
+  const hits = (response.data ?? []).map((chunk) => {
+    const meta = chunk.generated_metadata ?? {};
+    return {
+      excerpt: chunk.text ?? meta.excerpt ?? "",
+      title: meta.title ?? chunk.filename ?? "",
+      url: meta.url ?? "",
+    };
+  });
+  return new Response(JSON.stringify(hits), {
+    headers: { "Content-Type": "application/json" },
+  });
+};
+`;
+var rawMarkdownEndpointTemplate = (kind) => `// Generated by Blume. Do not edit.
+import raw from "blume:raw-markdown";
+
+export const prerender = true;
+
+export function getStaticPaths() {
+  return Object.keys(raw).map((route) => ({
+    params: { slug: route === "/" ? "index" : route.slice(1) },
+    props: { route },
+  }));
+}
+
+export function GET({ props }: { props: { route: string } }) {
+  const entries = raw as Record<string, { md?: string; mdx?: string }>;
+  const entry = entries[props.route];
+  const body = entry ? ${kind === "md" ? '(entry.md ?? entry.mdx ?? "")' : '(entry.mdx ?? "")'} : "";
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/markdown; charset=utf-8",
+      // ~4 characters per token; keep in sync with markdownTokenCount.
+      "x-markdown-tokens": String(Math.ceil(body.length / 4)),
+    },
+  });
+}
+`;
+var contentAssetsEndpointTemplate = (stagedAssetsDir) => `// Generated by Blume. Do not edit.
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import type { APIRoute } from "astro";
+import assets from "blume:content-assets";
+
+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.
+  // path.relative rather than a string-prefix test: STAGED_DIR is baked in
+  // with forward slashes while resolve() answers in the platform's
+  // separators, so on Windows the prefix test 404'd every legitimate staged
+  // asset — and a bare prefix also admits a sibling directory that merely
+  // shares the name.
+  const rel = relative(STAGED_DIR, abs);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
+    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 = () => `// Generated by Blume. Do not edit.
+import type { APIRoute } from "astro";
+import { createMcpFetchHandler } from "blume/ai/mcp/server.ts";
+import data from "blume:mcp-data";
+
+export const prerender = false;
+
+const handler = createMcpFetchHandler(data);
+
+export const ALL: APIRoute = ({ request }) => handler(request);
+`;
+var playgroundProxyTemplate = (origins) => `// Generated by Blume. Do not edit.
+import type { APIRoute } from "astro";
+import { createPlaygroundProxyHandler } from "blume/openapi/proxy.ts";
+
+export const prerender = false;
+
+const handler = createPlaygroundProxyHandler(${JSON.stringify(origins)});
+
+export const ALL: APIRoute = ({ request }) => handler(request);
+`;
+var staticJsonEndpointTemplate = (payload) => `// Generated by Blume. Do not edit.
+export const prerender = true;
+
+const payload = ${JSON.stringify(payload, null, 2)};
+
+export function GET() {
+  return new Response(JSON.stringify(payload), {
+    headers: { "Content-Type": "application/json" },
+  });
+}
+`;
+var rssEndpointTemplate = () => `// Generated by Blume. Do not edit.
+import feeds from "blume:rss";
+
+export const prerender = true;
+
+export function getStaticPaths() {
+  return Object.keys(feeds).map((section) => ({
+    params: { section },
+    props: { section },
+  }));
+}
+
+export function GET({ props }: { props: { section: string } }) {
+  const bySection = feeds as Record<string, string>;
+  return new Response(bySection[props.section] ?? "", {
+    headers: { "Content-Type": "application/rss+xml; charset=utf-8" },
+  });
+}
+`;
+var navFragmentTemplate = () => `---
+// Generated by Blume. Do not edit.
+import NavTree from "blume/components/layout/NavTree.astro";
+import { withBase } from "blume/components/islands/base-path.ts";
+import { navGroupIds, navVariants } from "blume/components/layout/nav-utils.ts";
+import type { NavNode } from "blume/core/types.ts";
+import data from "blume:data";
+
+export const prerender = true;
+// A partial: no doctype, head, or script/style injection — the rows only.
+export const partial = true;
+
+// Only imports are in scope here (Astro hoists getStaticPaths), which is why
+// the variant walk lives in nav-utils.
+export function getStaticPaths() {
+  return navVariants(data).flatMap(({ locale, navigation, version }) =>
+    [...navGroupIds(navigation.sidebar)]
+      .filter(([node]) => (node.display ?? "flat") !== "flat")
+      .map(([, id]) => ({ params: { id, locale, version } }))
+  );
+}
+
+const { id, locale, version } = Astro.params;
+const variant = navVariants(data).find(
+  (entry) => entry.version === version && entry.locale === locale
+);
+const ids = variant
+  ? navGroupIds(variant.navigation.sidebar)
+  : new Map<NavNode, string>();
+const node = [...ids].find(([, groupId]) => groupId === id)?.[0];
+if (!(variant && node && node.kind === "group")) {
+  return new Response(null, { status: 404 });
+}
+const strings =
+  locale === "default" ? data.ui.nav : (data.uiByLocale[locale] ?? data.ui).nav;
+const fragmentBase = withBase(\`/blume-nav/\${version}/\${locale}\`);
+---
+
+<NavTree
+  currentRoute=""
+  depth={1}
+  fragmentBase={fragmentBase}
+  idPrefix={id}
+  ids={ids}
+  items={node.children}
+  root={false}
+  strings={strings}
+/>
+`;
+var ogEndpointTemplate = (customRoutes = [], og = {}, includeChangelog = false) => `// Generated by Blume. Do not edit.
+import { cachedOgImage } from "blume/og";
+import type { OgCache, OgFont, OgFontFamilies } from "blume/og";
+import data from "blume:data";
+
+export const prerender = true;
+
+// Custom (non-content) pages opted into a generated card, baked in at build.
+// The annotation keeps the empty-array case from being an implicit any[]
+// (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"};
+
+// Rendered cards are kept on disk between builds, keyed by everything that
+// decides their pixels, so a rebuild renders only the cards whose title,
+// description, branding, or fonts changed. The directory is a build-machine
+// path, baked in for the same reason as the local font paths above.
+const cache: OgCache | undefined = ${og.cache ? JSON.stringify(og.cache) : "undefined"};
+
+// A page's own description (its \`seo.description\`, else \`description\`) is
+// the card subtitle, so the image says what the page's og:description says.
+// Pages without one fall back to the site-wide subtitle at render time.
+// \`seo.og.description: false\` hides the subtitle on every card, page text
+// included, which is what switches this off.
+const pageDescriptions = ${og.pageDescriptions !== false};
+
+interface CardProps {
+  title: string;
+  description: string | null;
+}
+
+export function getStaticPaths() {
+  const seen = new Set<string>();
+  const paths: { params: { slug: string }; props: CardProps }[] = [];
+  const add = (slug: string, title: string, description: string | null) => {
+    if (seen.has(slug)) {
+      return;
+    }
+    seen.add(slug);
+    paths.push({
+      params: { slug },
+      props: { title, description: pageDescriptions ? description : null },
+    });
+  };
+  // A custom page wins over a content route sharing its path, so add it first.
+  // Its description is unknown at generate time, so it takes the site subtitle.
+  for (const route of customRoutes) {
+    add(route.slug, route.title, null);
+  }
+  for (const route of data.routes) {
+    add(
+      route.path === "/" ? "index" : route.path.slice(1),
+      route.title,
+      route.description
+    );
+  }${includeChangelog ? `
+  // The generated changelog index is not a content route, so it needs its own
+  // card. Added last: a custom page or content route owning /changelog wins.
+  add(
+    "changelog",
+    data.ui.changelog?.title ?? "Changelog",
+    data.ui.changelog?.description ?? null
+  );` : ""}
+  return paths;
+}
+
+// Footer branding shared by every card. The slug comes from the configured
+// repo rather than the URL, so an Enterprise host reads the same as github.com;
+// the site text (host plus deployment base) is resolved at generate time.
+const repoSlug = data.config.github
+  ? \`\${data.config.github.owner}/\${data.config.github.repo}\`
+  : undefined;
+
+export async function GET({ props }: { props: CardProps }) {
+  const png = await cachedOgImage(cache, {
+    accent: data.config.og.palette?.accent ?? data.config.theme.accent.light,
+    brand: data.config.title,
+    description: props.description ?? data.config.og.description,
+    families,
+    fonts,
+    logo: data.config.og.logo,
+    palette: data.config.og.palette,
+    repo: repoSlug,
+    site: data.config.og.site,
+    title: props.title,
+  });
+  return new Response(new Uint8Array(png), {
+    headers: {
+      "Cache-Control": "public, max-age=31536000, immutable",
+      "Content-Type": "image/png",
+    },
+  });
+}
+`;
+var scalarReferenceTemplate = (options) => `---
+// Generated by Blume. Do not edit.
+import { ScalarComponent } from "@scalar/astro";
+import ReferenceLayout from "blume/components/layout/ReferenceLayout.astro";
+import data from "blume:data";
+
+export const prerender = true;
+
+const configuration = ${JSON.stringify(options.configuration, null, 2)};
+
+// The reference is an unlocalized route, so its chrome renders in the default
+// locale's language and direction (\`data.ui\` is the default locale's resolved
+// dictionary), mirroring the changelog index's locale wiring.
+const i18n = data.config.i18n;
+const localeMeta = i18n
+  ? i18n.locales.find((l) => l.code === i18n.defaultLocale)
+  : null;
+const dir = localeMeta?.dir ?? "ltr";
+const htmlLang = i18n ? i18n.defaultLocale : "en";
+---
+
+<ReferenceLayout
+  analytics={data.config.analytics}
+  banner={data.config.banner}
+  dir={dir}
+  fontCssVars={data.fontCssVars}
+  locale={htmlLang}
+  logo={data.config.logo}
+  favicon={data.config.favicon}
+  appleIcon={data.config.appleIcon}
+  navigation={data.navigation}
+  noindex={${options.noindex === true}}
+  pageTitle={${JSON.stringify(options.title)}}
+  route={${JSON.stringify(options.route)}}
+  searchEnabled={data.config.search.enabled}
+  site={{ title: data.config.title, description: data.config.description }}
+  themeMode={data.config.theme.mode}
+  ui={data.ui}
+>
+  <ScalarComponent configuration={configuration} renderMode="client" />
+</ReferenceLayout>
+`;
+var catchAllPageTemplate = (options) => {
+  const mathImport = options.mathEnabled ? `import Math from "blume/components/content/Math.astro";
+` : "";
+  const mathEntry = options.mathEnabled ? `Math,
+  ` : "";
+  const clientData = options.needsReact ? `
+  clientData={{ config: data.config, navigation, page: { route, title: seo.title ?? title } }}` : "";
+  return `---
+// Generated by Blume. Do not edit.
+import { getEntry, render } from "astro:content";
+import type { CollectionKey } from "astro:content";
+import RootLayout from "blume/components/layout/RootLayout.astro";
+import { withBase } from "blume/components/islands/base-path.ts";
+import { stripBasePath, withBasePath } from "blume/core/base-path.ts";
+import { resolveSlot } from "blume/components/layout/overrides.ts";
+import Accordion from "blume/components/content/Accordion.astro";
+import AccordionItem from "blume/components/content/AccordionItem.astro";
+import AutoTypeTable from "blume/components/content/AutoTypeTable.astro";
+import Badge from "blume/components/content/Badge.astro";
+import Callout from "blume/components/content/Callout.astro";
+import Card from "blume/components/content/Card.astro";
+import CardGroup from "blume/components/content/CardGroup.astro";
+import CodeBlock from "blume/components/content/CodeBlock.astro";
+import CodeGroup from "blume/components/content/CodeGroup.astro";
+import ColorRoot from "blume/components/content/Color.astro";
+import ColorItem from "blume/components/content/ColorItem.astro";
+import ColorRow from "blume/components/content/ColorRow.astro";
+import Column from "blume/components/content/Column.astro";
+import Columns from "blume/components/content/Columns.astro";
+import Component from "blume/components/content/Component.astro";
+import Diff from "blume/components/content/Diff.astro";
+import Expandable from "blume/components/content/Expandable.astro";
+import FileTree from "blume/components/content/FileTree.astro";
+import Frame from "blume/components/content/Frame.astro";
+import GithubInfo from "blume/components/content/GithubInfo.astro";
+import Panel from "blume/components/content/Panel.astro";
+import Prompt from "blume/components/content/Prompt.astro";
+import Step from "blume/components/content/Step.astro";
+import Steps from "blume/components/content/Steps.astro";
+import Tab from "blume/components/content/Tab.astro";
+import Tabs from "blume/components/content/Tabs.astro";
+import Tile from "blume/components/content/Tile.astro";
+import Tooltip from "blume/components/content/Tooltip.astro";
+import TreeRoot from "blume/components/content/Tree.astro";
+import TreeFile from "blume/components/content/TreeFile.astro";
+import TreeFolder from "blume/components/content/TreeFolder.astro";
+import TypeTable from "blume/components/content/TypeTable.astro";
+import Visibility from "blume/components/content/Visibility.astro";
+import YouTube from "blume/components/content/YouTube.astro";
+import Icon from "blume/components/Icon.astro";
+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";
+import data from "blume:data";
+
+const Color = Object.assign(ColorRoot, { Item: ColorItem, Row: ColorRow });
+const Tree = Object.assign(TreeRoot, { File: TreeFile, Folder: TreeFolder });
+
+// Docs content is file-based and always prerendered, even in server output
+// (where only endpoints like /api/ask render on demand). Without this, server
+// builds would render this route on demand and ignore getStaticPaths, leaving
+// the entry id undefined.
+export const prerender = true;
+
+const components = {
+  Accordion,
+  AccordionItem,
+  ApiOverview,
+  ApiTagOperations,
+  AutoTypeTable,
+  Badge,
+  Callout,
+  Card,
+  CardGroup,
+  CodeBlock,
+  CodeGroup,
+  Color,
+  Column,
+  Columns,
+  Component,
+  Diff,
+  Expandable,
+  FileTree,
+  Frame,
+  GithubInfo,
+  Icon,
+  Operation,
+  Panel,
+  Prompt,
+  Step,
+  Steps,
+  Tab,
+  Tabs,
+  Tile,
+  Tooltip,
+  Tree,
+  TypeTable,
+  Visibility,
+  YouTube,
+  ${mathEntry}...islandComponents,
+  ...userMdx,
+};
+
+export function getStaticPaths() {
+  return data.routes.map((route) => ({
+    params: { slug: route.path === "/" ? undefined : route.path.slice(1) },
+    props: {
+      alternates: route.alternates,
+      collection: route.collection,
+      editUrl: route.editUrl,
+      entryId: route.entryId,
+      fallback: route.fallback,
+      indexable: route.indexable,
+      lastModified: route.lastModified,
+      locale: route.locale,
+      route: route.path,
+      title: route.title,
+      version: route.version,
+      versionAlternates: route.versionAlternates,
+    },
+  }));
+}
+
+const { entryId, collection, route, title, indexable, editUrl, lastModified, locale, alternates, fallback, version, versionAlternates } = Astro.props;
+const entry = await getEntry(collection as CollectionKey, entryId);
+if (!entry) {
+  return new Response(null, { status: 404 });
+}
+const { Content, headings: allHeadings, remarkPluginFrontmatter } = await render(entry);
+// \`[!toc]\`-marked headings render on the page but stay out of the table of
+// contents; the heading plugin reports their slugs through the render's
+// frontmatter (see markdown/heading-anchors.ts). Only the plugin's array
+// counts: \`frontmatter.extend\` can declare the same key, and on a page with
+// no headings that user-supplied value would pass straight through.
+const tocHiddenRaw = remarkPluginFrontmatter?.${TOC_HIDDEN_KEY};
+const tocHidden = new Set(Array.isArray(tocHiddenRaw) ? tocHiddenRaw : []);
+const headings =
+  tocHidden.size > 0
+    ? allHeadings.filter((heading) => !tocHidden.has(heading.slug))
+    : allHeadings;
+const frontmatter = entry.data;
+
+const seo = frontmatter.seo;
+const base = data.config.site ? data.config.site.replace(/\\/$/, "") : null;
+
+// Percent-encode the route-derived path (the sitemap convention): a Unicode
+// slug (\`/api/größe\`) is not legal in a raw URI, and crawlers compare
+// canonical against the sitemap's encoded <loc> byte-for-byte.
+const ogPath = data.config.og.enabled
+  ? encodeURI(\`/og/\${route === "/" ? "index" : route.slice(1)}.png\`)
+  : null;
+const ogRel = seo.image ?? ogPath;
+// Absolute URLs also carry the deployment base (the page is served under it):
+// \`site + base + path\`. Only absolutize root-relative paths: \`seo.image\` may be
+// an external URL, which passes through verbatim (mirrors PageLayout).
+const ogImage =
+  ogRel && base && ogRel.startsWith("/") ? \`\${base}\${withBase(ogRel)}\` : ogRel;
+// Blume's generated card has known dimensions the layout can declare; a user's
+// \`seo.image\` could be any size or format, so it gets none.
+const ogGenerated = !seo.image && Boolean(ogPath);
+
+// X attribution: the site's account, plus a creator the page can claim for
+// itself (a guest post crediting its own author) over the configured default.
+const x = { ...data.config.x, ...(seo.x?.creator ? { creator: seo.x.creator } : {}) };
+
+const basedRoute = withBase(route);
+
+// Locale resolution. With i18n on, pick the active locale's nav + dictionary,
+// build hreflang alternates, and derive the language-switcher targets.
+const i18n = data.config.i18n;
+const localePrefix = (codeArg: string) =>
+  i18n && codeArg === i18n.defaultLocale && i18n.hideDefaultLocalePrefix
+    ? ""
+    : \`/\${codeArg}\`;
+const localizeRoute = (logical: string, codeArg: string) => {
+  const prefix = localePrefix(codeArg);
+  if (!prefix) {
+    return logical;
+  }
+  return logical === "/" ? prefix : \`\${prefix}\${logical}\`;
+};
+const stripLocale = (path: string, codeArg: string) => {
+  const prefix = localePrefix(codeArg);
+  return prefix && path.startsWith(prefix) ? path.slice(prefix.length) || "/" : path;
+};
+
+// Version resolution. An archived page renders its snapshot's navigation tree,
+// points its canonical at the latest equivalent (unless configured otherwise),
+// and shows the old-version notice.
+const versionsConfig = data.config.versions;
+const archived = versionsConfig && version
+  ? (versionsConfig.archived.find((v) => v.id === version) ?? null)
+  : null;
+const latestVersionAlt = (versionAlternates ?? []).find((alt) => alt.version === "");
+
+const navigation = version
+  ? (data.navigationByVersion[version]?.[i18n ? locale : ""] ?? data.navigation)
+  : i18n
+    ? (data.navigationByLocale[locale] ?? data.navigation)
+    : data.navigation;
+const ui = i18n ? (data.uiByLocale[locale] ?? data.ui) : data.ui;
+const localeMeta = i18n ? i18n.locales.find((l) => l.code === locale) : null;
+const dir = localeMeta?.dir ?? "ltr";
+const htmlLang = i18n ? locale : "en";
+// A fallback page renders the fallback locale's content, so its text direction
+// follows that language — not the (mirrored) page locale.
+const contentLocale =
+  fallback && i18n?.fallbackLocale ? i18n.fallbackLocale : locale;
+const contentDir = i18n
+  ? (i18n.locales.find((l) => l.code === contentLocale)?.dir ?? "ltr")
+  : "ltr";
+// The root route keeps its trailing slash (\`https://site/\`) so canonical and
+// hreflang URLs byte-match the sitemap's <loc> for the home page.
+const absolute = (path: string) => base + withBase(path);
+
+// 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
+    ? absolute(latestVersionAlt.path)
+    : base
+      ? \`\${base}\${basedRoute === "/" ? "/" : encodeURI(basedRoute)}\`
+      : null);
+const effectiveNoindex = Boolean(seo.noindex) || (archived?.noindex ?? false);
+
+const localeAlternates =
+  i18n && base
+    ? (alternates ?? []).map((alt) => ({ hreflang: alt.locale, href: absolute(alt.path) }))
+    : [];
+const defaultAlt = i18n ? (alternates ?? []).find((alt) => alt.locale === i18n.defaultLocale) : null;
+const xDefault = defaultAlt && base ? absolute(defaultAlt.path) : null;
+
+// \`route\` arrives with \`basePath\` already applied, so the locale segment it
+// carries sits *after* the base (\`/docs/ja/guide\`), while \`localePrefix\` is
+// base-less (\`/ja\`). Stripping and re-adding a locale therefore happen in
+// base-less space, with the base re-applied at the end — the same
+// \`withBasePath(basePath, localizeRoute(...))\` composition the manifest uses to
+// build every real route. Done in based space, \`stripLocale\` matches nothing
+// and \`localizeRoute\` prepends a second prefix (\`/ja/docs/ja/guide\`). Only a
+// switcher entry for a locale with no real translation reaches this fallback:
+// a partially translated hand-written page for its missing locales, or a
+// generated reference (which has no \`alternates\` at all) for every locale
+// but its own.
+const mountLocalized = (logical: string, codeArg: string) =>
+  withBasePath(data.config.basePath, localizeRoute(logical, codeArg));
+const logicalRoute = i18n
+  ? stripLocale(stripBasePath(data.config.basePath, route), locale)
+  : route;
+const localeSwitch = i18n
+  ? i18n.locales.map((l) => {
+      const alt = (alternates ?? []).find((x) => x.locale === l.code);
+      return {
+        code: l.code,
+        current: l.code === locale,
+        dir: l.dir,
+        href: alt ? alt.path : mountLocalized(logicalRoute, l.code),
+        label: l.label,
+        untranslated: !alt,
+      };
+    })
+  : [];
+
+// Version switcher + old-version notice. The switcher auto-populates from the
+// versions config as a \`kind: "version"\` selector; a user-declared version
+// selector in \`navigation.selectors\` suppresses it (theirs renders instead).
+// Fallback version roots compose like real routes — \`{basePath}/{locale?}/{id}\`
+// (manifest \`versionAlternates\` paths arrive with the base already applied).
+const versionRootFor = (id: string) => {
+  const logical = id ? \`/\${id}\` : "/";
+  return i18n
+    ? mountLocalized(logical, locale)
+    : withBasePath(data.config.basePath, logical);
+};
+const samePageSwitch = versionsConfig
+  ? versionsConfig.switcher.redirect === "same-page"
+  : true;
+const userHasVersionSelector = navigation.selectors.some(
+  (selector) => selector.kind === "version"
+);
+const versionSelector =
+  versionsConfig && !userHasVersionSelector
+    ? {
+        items: [
+          {
+            id: "",
+            label: versionsConfig.current.label,
+            tag: versionsConfig.current.badge,
+          },
+          ...versionsConfig.archived.map((v) => ({
+            id: v.id,
+            label: v.label ?? v.id,
+            tag: undefined,
+          })),
+        ].map((entry) => {
+          const alt = (versionAlternates ?? []).find(
+            (a) => a.version === entry.id
+          );
+          return {
+            label: entry.label,
+            path: samePageSwitch && alt ? alt.path : versionRootFor(entry.id),
+            ...(entry.tag ? { tag: entry.tag } : {}),
+          };
+        }),
+        kind: "version" as const,
+        label: ui.versions.switcher,
+      }
+    : null;
+
+const versionNotice =
+  archived && archived.banner !== false
+    ? {
+        latestHref: latestVersionAlt
+          ? latestVersionAlt.path
+          : versionRootFor(""),
+        latestLabel: ui.versions.latest,
+        message:
+          typeof archived.banner === "string"
+            ? archived.banner
+            : ui.versions.notice.replace(
+                "{version}",
+                archived.label ?? archived.id
+              ),
+      }
+    : null;
+
+// The whole page shell is overridable via \`layout.Layout\`; it receives the same
+// props as the built-in RootLayout, plus the \`layout\` map for its inner slots.
+const LayoutComponent = resolveSlot(layoutOverrides.Layout, RootLayout);
+---
+
+<LayoutComponent
+  site={{ title: data.config.title, description: data.config.description }}
+  layout={layoutOverrides}${clientData}
+  logo={data.config.logo}
+  mcp={data.config.mcp}
+  favicon={data.config.favicon}
+  appleIcon={data.config.appleIcon}
+  banner={data.config.banner}
+  analytics={data.config.analytics}
+  imageZoom={data.config.imageZoom}
+  codeWrap={data.config.codeWrap}
+  navigation={navigation}
+  locale={htmlLang}
+  dir={dir}
+  contentDir={contentDir}
+  ui={ui}
+  localeAlternates={localeAlternates}
+  xDefault={xDefault}
+  localeSwitch={localeSwitch}
+  versionSelector={versionSelector}
+  versionNotice={versionNotice}
+  searchVersion={versionsConfig ? version : null}
+  page={{ title: seo.title ?? title, description: seo.description ?? frontmatter.description, route }}
+  headings={headings}
+  toc={data.config.toc}
+  dateFormat={data.config.dateFormat}
+  themeMode={data.config.theme.mode}
+  fontCssVars={data.fontCssVars}
+  searchEnabled={data.config.search.enabled}
+  indexable={indexable}
+  ogImage={ogImage}
+  ogGenerated={ogGenerated}
+  x={x}
+  canonical={canonical}
+  editUrl={editUrl}
+  feedback={data.config.feedback}
+  exportPdf={${options.exportPdf}}
+  exportEpub={${options.exportEpub}}${options.navFragments ? `
+  navFragmentBase={withBase(\`/blume-nav/\${version || "current"}/\${i18n ? locale : "default"}\`)}` : ""}
+  openInChat={data.config.openInChat}
+  feeds={data.feeds}
+  discovery={data.config.discovery}
+  siteUrl={data.config.site}
+  pageType={frontmatter.type}
+  published={frontmatter.date ?? frontmatter.changelog?.date ?? null}
+  lastModified={lastModified}
+  noindex={effectiveNoindex}
+  structuredDataEnabled={data.config.structuredData}
+>
+  <h1>{title}</h1>
+  {frontmatter.description && <p class="text-lg text-muted-foreground">{frontmatter.description}</p>}
+  <LocaleLinks locale={locale}>
+    <Content components={components} />
+  </LocaleLinks>
+</LayoutComponent>
+`;
+};
+var changelogIndexTemplate = (options) => {
+  const clientData = options.needsReact ? `
+  clientData={{ config: data.config, navigation: data.navigation, page: { route: "/changelog", title: pageTitle } }}` : "";
+  const stagedSpread = options.staged ? `
+  ...(await getCollection("staged")),` : "";
+  return `---
+// Generated by Blume. Do not edit.
+import { getCollection, render } 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";
+import { layoutOverrides } from "../generated/components.ts";
+import data from "blume:data";
+
+export const prerender = true;
+
+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) => {
+  if (!value) {
+    return 0;
+  }
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? 0 : date.getTime();
+};
+
+// The changelog is an unlocalized route, so its chrome renders in the default
+// locale's dictionary and direction (\`data.ui\` is the default locale's resolved
+// dictionary), mirroring the catch-all's locale wiring.
+const i18n = data.config.i18n;
+const localeMeta = i18n
+  ? i18n.locales.find((l) => l.code === i18n.defaultLocale)
+  : null;
+const dir = localeMeta?.dir ?? "ltr";
+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.
+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 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])
+);
+
+const changelogEntries = [
+  ...(await getCollection("docs")),${stagedSpread}
+]
+  .filter(
+    (entry) =>
+      entry.data.type === "changelog" &&
+      !entry.data.draft &&
+      !entry.data.sidebar?.hidden
+  )
+  .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]
+        : [],
+    };
+  })
+);
+
+// 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.
+const seenIds = new Set();
+for (const item of items) {
+  let uniqueId = item.id;
+  for (let n = 2; seenIds.has(uniqueId); n += 1) {
+    uniqueId = item.id + "-" + n;
+  }
+  seenIds.add(uniqueId);
+  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,
+}));
+
+const base = data.config.site ? data.config.site.replace(/\\/$/, "") : null;
+// The canonical URL carries the deployment base (the page is served under it),
+// matching how the catch-all canonicalizes via \`withBase(route)\`.
+const basedRoute = withBase("/changelog");
+const canonical = base ? base + basedRoute : null;
+
+// The generated OG card for this route (the /og endpoint emits it alongside
+// the content-route cards), absolutized like the catch-all's so crawlers get
+// a full URL when the site is known.
+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.
+const changelogTitle = data.ui.changelog?.title ?? "Changelog";
+const changelogDescription =
+  data.ui.changelog?.description ??
+  "Product updates, new features, and fixes from every release.";
+// The layout suffixes "- {site title}" itself, so the page title is just the
+// changelog's own name — prefixing the site title too would double it
+// ("Acme Changelog - Acme").
+const pageTitle = changelogTitle;
+
+const LayoutComponent = resolveSlot(layoutOverrides.Layout, RootLayout);
+---
+
+<LayoutComponent
+  site={{ title: data.config.title, description: data.config.description }}
+  layout={layoutOverrides}${clientData}
+  logo={data.config.logo}
+  mcp={data.config.mcp}
+  favicon={data.config.favicon}
+  appleIcon={data.config.appleIcon}
+  banner={data.config.banner}
+  analytics={data.config.analytics}
+  imageZoom={data.config.imageZoom}
+  codeWrap={data.config.codeWrap}
+  navigation={data.navigation}
+  locale={htmlLang}
+  dir={dir}
+  ui={data.ui}
+  page={{
+    title: pageTitle,
+    description: changelogDescription,
+    route: "/changelog",
+  }}
+  headings={headings}
+  toc={data.config.toc}
+  contentLayout="bare"
+  themeMode={data.config.theme.mode}
+  fontCssVars={data.fontCssVars}
+  searchEnabled={data.config.search.enabled}
+  indexable={true}
+  ogImage={ogImage}
+  ogGenerated={Boolean(ogImage)}
+  x={data.config.x}
+  canonical={canonical}
+  exportPdf={${options.exportPdf}}
+  exportEpub={${options.exportEpub}}
+  openInChat={data.config.openInChat}
+  feeds={data.feeds}
+  discovery={data.config.discovery}
+  siteUrl={data.config.site}
+  noindex={false}
+  structuredDataEnabled={data.config.structuredData}
+>
+  <h1>{changelogTitle}</h1>
+  {
+    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 />
+          </Update>
+        ))}
+        {majorGroups.slice(1).map((group) => (
+          <section
+            aria-label={group.label + " releases"}
+            data-changelog-label={group.label}
+            data-changelog-major={group.major}
+          >
+            {group.items.map(({ Content, href, id, label, date, tags }) => (
+              <Update description={date} href={href} id={id} label={label} tags={tags}>
+                <Content />
+              </Update>
+            ))}
+          </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 />
+          </Update>
+        ))}
+      </div>
+    )
+  }
+  <script>
+    import "blume/components/content/changelog-element.ts";
+  </script>
+</LayoutComponent>
+`;
+};
+var notFoundPageTemplate = () => `---
+// Generated by Blume. Do not edit. Override by adding \`pages/404.astro\`.
+import Icon from "blume/components/Icon.astro";
+import PageLayout from "blume/components/layout/PageLayout.astro";
+import { withBase } from "blume/components/islands/base-path.ts";
+import data from "blume:data";
+
+export const prerender = true;
+
+const nf = data.ui.notFound;
+
+// The 404 page is an unlocalized route, so its chrome renders in the default
+// locale's dictionary and direction (\`data.ui\` is the default locale's resolved
+// dictionary), mirroring the catch-all's locale wiring.
+const i18n = data.config.i18n;
+const localeMeta = i18n
+  ? i18n.locales.find((l) => l.code === i18n.defaultLocale)
+  : null;
+const dir = localeMeta?.dir ?? "ltr";
+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
+// their resolved target when the section has no index page of its own.
+const suggestions = [
+  ...data.navigation.tabs.map((tab) => ({
+    href: withBase(tab.href ?? tab.path),
+    label: tab.label,
+  })),
+  ...(data.config.discovery.sitemap
+    ? [{ href: withBase("/sitemap.xml"), label: nf.sitemap }]
+    : []),
+  ...(data.config.discovery.llmsTxt
+    ? [{ href: withBase("/llms.txt"), label: nf.llms }]
+    : []),
+];
+---
+
+<PageLayout
+  site={{ title: data.config.title, description: data.config.description }}
+  logo={data.config.logo}
+  favicon={data.config.favicon}
+  appleIcon={data.config.appleIcon}
+  banner={data.config.banner}
+  analytics={data.config.analytics}
+  navigation={data.navigation}
+  page={{ title: nf.title, route: "/404" }}
+  themeMode={data.config.theme.mode}
+  fontCssVars={data.fontCssVars}
+  searchEnabled={data.config.search.enabled}
+  locale={htmlLang}
+  dir={dir}
+  ui={data.ui}
+  noindex={true}
+>
+  <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"
+  >
+    <div class="flex flex-col items-start">
+      <p
+        class="font-mono text-xs font-medium tracking-widest text-muted-foreground"
+      >
+        404
+      </p>
+      <h1
+        class="mt-4 text-balance text-4xl font-semibold tracking-tight text-foreground sm:text-5xl"
+      >
+        {nf.title}
+      </h1>
+      <p class="mt-4 max-w-md text-pretty text-lg text-muted-foreground">
+        {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"
+        href={withBase("/")}
+      >
+        <Icon class="rtl:-scale-x-100" name="arrow-left" size={14} />
+        {nf.home}
+      </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">
+            {nf.suggestions}
+          </h2>
+          <ul class="mt-4 divide-y divide-border border-y border-border">
+            {suggestions.map((link) => (
+              <li>
+                <a
+                  class="group flex items-center justify-between gap-4 py-3 text-sm font-medium text-foreground transition-colors hover:text-accent"
+                  href={link.href}
+                >
+                  <span>{link.label}</span>
+                  <Icon
+                    class="shrink-0 text-muted-foreground transition-transform group-hover:translate-x-0.5 rtl:-scale-x-100 rtl:group-hover:-translate-x-0.5"
+                    name="arrow-right"
+                    size={14}
+                  />
+                </a>
+              </li>
+            ))}
+          </ul>
+        </nav>
+      )
+    }
+  </div>
+</PageLayout>
+`;
+var notFoundMarkdownTemplate = () => `// Generated by Blume. Do not edit. Override by adding \`pages/404.astro\`.
+import { withBase } from "blume/components/islands/base-path.ts";
+import { absoluteUrl } from "blume/core/site-url.ts";
+import data from "blume:data";
+
+export const prerender = true;
+
+const nf = data.ui.notFound;
+
+// Absolute for internal routes when the site is known; an external tab href
+// passes through untouched.
+const href = (path: string): string => {
+  const based = withBase(path);
+  return data.config.site && based.startsWith("/") && !based.startsWith("//")
+    ? absoluteUrl(data.config.site, based)
+    : based;
+};
+
+// The recovery set of 404.astro: home, every top-level section (a tab links to
+// its resolved target), then the machine-readable indexes that exist.
+const links = [
+  { href: href("/"), label: nf.home },
+  ...data.navigation.tabs.map((tab) => ({
+    href: href(tab.href ?? tab.path),
+    label: tab.label,
+  })),
+  ...(data.config.discovery.sitemap
+    ? [{ href: href("/sitemap.xml"), label: nf.sitemap }]
+    : []),
+  ...(data.config.discovery.llmsTxt
+    ? [{ href: href("/llms.txt"), label: nf.llms }]
+    : []),
+  ...(data.config.discovery.api
+    ? [{ href: href("/openapi.json"), label: nf.api }]
+    : []),
+];
+
+const body = [
+  "# " + nf.title,
+  "",
+  nf.description,
+  "",
+  "## " + nf.suggestions,
+  "",
+  ...links.map((link) => "- [" + link.label + "](" + link.href + ")"),
+  "",
+].join("\\n");
+
+export function GET() {
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/markdown; charset=utf-8",
+      // ~4 characters per token; keep in sync with markdownTokenCount.
+      "x-markdown-tokens": String(Math.ceil(body.length / 4)),
+    },
+  });
+}
+`;
+var notFoundJsonTemplate = () => `// Generated by Blume. Do not edit. Override by adding \`pages/404.astro\`.
+import { problem } from "blume/ai/api/problem.ts";
+import { withBase } from "blume/components/islands/base-path.ts";
+import { absoluteUrl } from "blume/core/site-url.ts";
+import data from "blume:data";
+
+export const prerender = true;
+
+const nf = data.ui.notFound;
+
+// Absolute for internal routes when the site is known; an external tab href
+// passes through untouched.
+const href = (path: string): string => {
+  const based = withBase(path);
+  return data.config.site && based.startsWith("/") && !based.startsWith("//")
+    ? absoluteUrl(data.config.site, based)
+    : based;
+};
+
+// The recovery set of 404.astro: home, every top-level section (a tab links to
+// its resolved target), then the machine-readable indexes that exist.
+const links = [
+  { href: href("/"), label: nf.home },
+  ...data.navigation.tabs.map((tab) => ({
+    href: href(tab.href ?? tab.path),
+    label: tab.label,
+  })),
+  ...(data.config.discovery.sitemap
+    ? [{ href: href("/sitemap.xml"), label: nf.sitemap }]
+    : []),
+  ...(data.config.discovery.llmsTxt
+    ? [{ href: href("/llms.txt"), label: nf.llms }]
+    : []),
+  ...(data.config.discovery.api
+    ? [{ href: href("/openapi.json"), label: nf.api }]
+    : []),
+];
+
+const body = problem({
+  code: "PAGE_NOT_FOUND",
+  detail: nf.description,
+  links,
+  resolution: nf.suggestions + ": " + links.map((link) => link.href).join(", "),
+  status: 404,
+  title: nf.title,
+});
+
+export function GET() {
+  return new Response(JSON.stringify(body, null, 2) + "\\n", {
+    headers: { "Content-Type": "application/problem+json; charset=utf-8" },
+  });
+}
+`;
+var apiPagesIndexTemplate = () => `// Generated by Blume. Do not edit.
+import { pagesIndexResponse } from "blume/ai/api/handlers.ts";
+import data from "blume:mcp-data";
+
+export const prerender = true;
+
+export function GET() {
+  return pagesIndexResponse(data);
+}
+`;
+var apiPageTemplate = () => `// Generated by Blume. Do not edit.
+import { pageParams, pageResponse } from "blume/ai/api/handlers.ts";
+import data from "blume:mcp-data";
+
+export const prerender = true;
+
+export function getStaticPaths() {
+  return pageParams(data);
+}
+
+export function GET({ props }: { props: { route: string } }) {
+  return pageResponse(data, props.route);
+}
+`;
+var apiNavigationTemplate = () => `// Generated by Blume. Do not edit.
+import { navigationResponse } from "blume/ai/api/handlers.ts";
+import data from "blume:mcp-data";
+
+export const prerender = true;
+
+export function GET() {
+  return navigationResponse(data);
+}
+`;
+var apiSearchTemplate = () => `// Generated by Blume. Do not edit.
+import type { APIRoute } from "astro";
+import { createSearchHandler } from "blume/ai/api/handlers.ts";
+import data from "blume:mcp-data";
+
+export const prerender = false;
+
+const handler = createSearchHandler(data);
+
+export const GET: APIRoute = ({ request }) => handler(request);
+`;
+var apiNotFoundTemplate = (context) => `// Generated by Blume. Do not edit.
+import type { APIRoute } from "astro";
+import { apiNotFoundResponse } from "blume/ai/api/handlers.ts";
+
+export const prerender = false;
+
+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 "";
+  }
+  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) => `---
+// Generated by Blume. Do not edit.
+import Example from ${JSON.stringify(spec.file)};
+${wrapperPropsType("Example")}
+---
+<Example ${exampleDirective(spec)}{...Astro.props}><slot /></Example>
+`;
+var examplesRouteBase = (basePath) => `${basePath}/blume-examples`;
+var exampleMapTemplate = (specs, basePath) => {
+  const base = `export const examplesBase = ${JSON.stringify(examplesRouteBase(basePath))};`;
+  if (specs.length === 0) {
+    return `// Generated by Blume. Do not edit.
+${base}
+export const examples = {};
+`;
+  }
+  const imports = specs.map((spec, index) => `import E${index} from "./examples/${exampleSlug(spec.path)}.astro";`).join(`
+`);
+  const entries = specs.map((spec, index) => `  ${JSON.stringify(spec.path)}: { Component: E${index}, code: ${JSON.stringify(spec.source)}, lang: ${JSON.stringify(spec.lang)} },`).join(`
+`);
+  return `// Generated by Blume. Do not edit.
+${imports}
+${base}
+export const examples = {
+${entries}
+};
+`;
+};
+var examplesPageTemplate = () => `---
+// Generated by Blume. Do not edit.
+import { examples } from "blume:examples";
+import "blume:examples-theme";
+
+// Prerendered even in server output, like docs content.
+export const prerender = true;
+
+export const getStaticPaths = () =>
+  Object.keys(examples).map((path) => ({ params: { path } }));
+
+const { path } = Astro.params;
+const entry = path ? examples[path] : undefined;
+if (!entry) {
+  return new Response(null, { status: 404 });
+}
+const Example = entry.Component;
+---
+
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="robots" content="noindex" />
+    <title>{path}</title>
+    <script is:inline>
+      (() => {
+        const root = document.documentElement;
+        const apply = (theme) => {
+          root.dataset.theme = theme;
+          root.classList.toggle("dark", theme === "dark");
+        };
+        const stored = () =>
+          localStorage.getItem("blume-theme") ??
+          (matchMedia("(prefers-color-scheme: dark)").matches
+            ? "dark"
+            : "light");
+        try {
+          const host = window.parent.document.documentElement;
+          apply(host.dataset.theme ?? stored());
+          new MutationObserver(() => {
+            apply(host.dataset.theme ?? stored());
+          }).observe(host, { attributeFilter: ["data-theme"] });
+        } catch {
+          apply(stored());
+        }
+      })();
+    </script>
+  </head>
+  <!-- Flex + margin:auto centers the example and, unlike place-items, keeps
+       the top edge reachable when the example outgrows the frame. -->
+  <body style="display:flex;min-height:100svh;padding:1.5rem">
+    <div data-blume-example style="margin:auto"><Example /></div>
+    <script is:inline>
+      (() => {
+        // Report the example's rendered height so the embedding docs page can
+        // size the preview pane to the content. The wrapper is observed rather
+        // than the body: the body stretches to the frame's own height, so it
+        // would only echo the pane back. Direct opens have no distinct parent
+        // and skip out; the frame is same-origin with the docs page (see the
+        // theme sync above), so the origin is pinned on both ends.
+        if (window.parent === window) {
+          return;
+        }
+        const wrapper = document.querySelector("[data-blume-example]");
+        if (!wrapper) {
+          return;
+        }
+        // The body's padding frames the example; fold it into the report so
+        // the parent can apply the number as-is. Read from the live value —
+        // the user's examples.css is injected after Blume's defaults precisely
+        // so their tokens win, so a root font-size override must be honored
+        // rather than assuming 1.5rem is 48px.
+        const bodyStyle = getComputedStyle(document.body);
+        const paddingPx =
+          parseFloat(bodyStyle.paddingTop) + parseFloat(bodyStyle.paddingBottom);
+        const report = () => {
+          window.parent.postMessage(
+            {
+              height:
+                Math.ceil(wrapper.getBoundingClientRect().height) + paddingPx,
+              type: "blume:example-height",
+            },
+            window.location.origin
+          );
+        };
+        new ResizeObserver(report).observe(wrapper);
+        // The parent asks for a fresh report when its listener comes up, in
+        // case the first one above was posted before anyone was listening.
+        window.addEventListener("message", (event) => {
+          if (
+            event.source === window.parent &&
+            event.origin === window.location.origin &&
+            event.data?.type === "blume:example-height-request"
+          ) {
+            report();
+          }
+        });
+      })();
+    </script>
+  </body>
+</html>
+`;
+var runtimePackageTemplate = (dependencies = []) => `${JSON.stringify({
+  dependencies: Object.fromEntries([...dependencies].toSorted().map((name) => [name, "*"])),
+  name: "blume-runtime",
+  private: true,
+  type: "module",
+  version: "0.0.0"
+}, null, 2)}
+`;
+var runtimeTsconfigTemplate = () => `${JSON.stringify({
+  exclude: ["dist"],
+  extends: "astro/tsconfigs/strict",
+  include: [".astro/types.d.ts", "**/*"]
+}, 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 };
+
+//# debugId=539E38867287181364756E2164756E21
+//# sourceMappingURL=chunk-agy5rzxy.js.map