blume 1.6.5 → 1.7.0

package/dist/cli/chunk-5d4q7121.js

@@ -0,0 +1,4064 @@
+#!/usr/bin/env node
+import {
+  buildMcpData,
+  buildRawMarkdown,
+  buildRssFeeds,
+  buildSearchDocuments,
+  markdownRoutePaths,
+  renderRssFeed
+} from "./chunk-ynacq3ev.js";
+import {
+  MCP_TOOLS
+} from "./chunk-pxj10x8y.js";
+import {
+  customOgRoutes,
+  discoverPages,
+  hasGeneratedChangelog,
+  routeIsTaken
+} from "./chunk-sbdqrjbb.js";
+import {
+  collectContentAssets,
+  rewriteRelativeImages
+} from "./chunk-v5mm027v.js";
+import {
+  writeTextAtomic
+} from "./chunk-ev67ycx0.js";
+import {
+  registry
+} from "./chunk-3r94j3tc.js";
+import {
+  apiNavigationTemplate,
+  apiNotFoundTemplate,
+  apiPageTemplate,
+  apiPagesIndexTemplate,
+  apiSearchTemplate,
+  askBackendRuntimeDep,
+  askComponentTemplate,
+  askEndpointTemplate,
+  astroConfigTemplate,
+  buildHomeLinkHeader,
+  catchAllPageTemplate,
+  changelogIndexTemplate,
+  contentAssetsEndpointTemplate,
+  contentConfigTemplate,
+  exampleMapTemplate,
+  exampleSlug,
+  exampleWrapperTemplate,
+  examplesPageTemplate,
+  featuresTemplate,
+  islandMapTemplate,
+  islandWrapperTemplate,
+  mcpEndpointTemplate,
+  mcpPageFile,
+  mixedbreadSearchEndpointTemplate,
+  navFragmentTemplate,
+  notFoundJsonTemplate,
+  notFoundMarkdownTemplate,
+  notFoundPageTemplate,
+  ogEndpointTemplate,
+  playgroundProxyTemplate,
+  publishRuntimeModules,
+  rawMarkdownEndpointTemplate,
+  resolveAskBackend,
+  rssEndpointTemplate,
+  runtimeDependencies,
+  runtimePackageTemplate,
+  runtimeTsconfigTemplate,
+  scalarReferenceTemplate,
+  searchClientTemplate,
+  searchEndpointTemplate,
+  stagedContentDir,
+  staticJsonEndpointTemplate
+} from "./chunk-agy5rzxy.js";
+import {
+  API_NAVIGATION_PATH,
+  API_PAGES_PATH,
+  API_PAGE_PATH,
+  API_SEARCH_PATH,
+  OPENAPI_PATH
+} from "./chunk-j6pxe0dt.js";
+import {
+  absoluteUrl,
+  siteRoot
+} from "./chunk-vxv4x1n8.js";
+import {
+  searchProviderMeta,
+  servesStaticIndex
+} from "./chunk-wd27zjcz.js";
+import {
+  apiNamePhrase,
+  buildIncludeGraph,
+  isOpenApiSource,
+  resolveDocsCollection,
+  resolveFallbackLocale,
+  validateNavTargets,
+  validateSearchPopularIcons
+} from "./chunk-s102bysw.js";
+import {
+  EN_UI,
+  GOOGLE_FONTS,
+  apiUrl,
+  buildFontsCss,
+  builtinProxyKinds,
+  configuredFonts,
+  editBaseUrl,
+  fontLocaleCodes,
+  hasScalarReferences,
+  isFontSlug,
+  needsPlaygroundProxy,
+  referenceRoutes,
+  repoUrl,
+  resolveReferences,
+  resolveUIStrings
+} from "./chunk-xv91q4nm.js";
+import {
+  normalizeBasePath,
+  trimChar,
+  withBasePath
+} from "./chunk-27gtm2ym.js";
+import {
+  getBlumeVersion
+} from "./chunk-4xyggvgf.js";
+import {
+  packageRoot
+} from "./chunk-6kzzpsx8.js";
+import {
+  BlumeError,
+  enrichDiagnostic
+} from "./chunk-ey89bjj1.js";
+
+// src/ai/web-bot-auth.ts
+var SIGNATURES_DIRECTORY_PATH = "/.well-known/http-message-signatures-directory";
+var SIGNATURES_DIRECTORY_TYPE = "application/http-message-signatures-directory+json";
+
+// src/astro/integration.ts
+import { join as join3, relative, resolve as resolve2 } from "pathe";
+
+// src/deploy/artifacts.ts
+import { dirname, join as join2, resolve } from "pathe";
+
+// src/search/build.ts
+import { join } from "pathe";
+
+// src/deploy/sitemap.ts
+import { escape as escapeXml } from "html-escaper";
+var ERROR_ROUTES = new Set(["/404", "/500"]);
+
+// src/astro/integration.ts
+var REGISTRY_KEY = Symbol.for("blume.integration");
+var registry2 = () => {
+  const host = globalThis;
+  host[REGISTRY_KEY] ??= {
+    buildProject: null,
+    negotiation: null,
+    overlay: null,
+    refreshContent: null
+  };
+  return host[REGISTRY_KEY];
+};
+var publishBuildProject = (project) => {
+  registry2().buildProject = project;
+};
+var publishDevNegotiation = (negotiation) => {
+  registry2().negotiation = negotiation ? {
+    contentRoutes: new Set(negotiation.contentRoutes),
+    homeLinkHeader: negotiation.homeLinkHeader
+  } : null;
+};
+var refreshBlumeContent = async () => {
+  const { refreshContent } = registry2();
+  if (!refreshContent) {
+    return false;
+  }
+  await refreshContent({});
+  return true;
+};
+var overlayChannel = () => {
+  const { overlay } = registry2();
+  return overlay?.ws ?? overlay?.hot;
+};
+var showBlumeErrorOverlay = (diagnostics) => {
+  const errors = [];
+  for (const diagnostic of diagnostics) {
+    if (diagnostic.severity === "error") {
+      errors.push(enrichDiagnostic(diagnostic));
+    }
+  }
+  const channel = overlayChannel();
+  if (errors.length === 0 || !channel) {
+    return;
+  }
+  const body = errors.map((diagnostic) => {
+    const lineSuffix = diagnostic.line ? `:${diagnostic.line}` : "";
+    const where = diagnostic.file ? `
+  at ${diagnostic.file}${lineSuffix}` : "";
+    const fix = diagnostic.suggestion ? `
+  fix: ${diagnostic.suggestion}` : "";
+    const docs = diagnostic.docsUrl ? `
+  docs: ${diagnostic.docsUrl}` : "";
+    return `[${diagnostic.code}] ${diagnostic.message}${where}${fix}${docs}`;
+  }).join(`
+
+`);
+  channel.send({
+    err: {
+      id: errors[0]?.file,
+      message: `Blume found ${errors.length} error(s):
+
+${body}`,
+      plugin: "blume",
+      stack: ""
+    },
+    type: "error"
+  });
+};
+
+// src/og/cache.ts
+import { existsSync } from "node:fs";
+import {
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  writeFile
+} from "node:fs/promises";
+import { dirname as dirname2, join as join4 } from "pathe";
+var ogCacheDir = (context) => existsSync(join4(context.root, "node_modules")) ? join4(context.root, "node_modules", ".cache", "blume", "og") : join4(context.outDir, ".cache", "og");
+var REGISTRY_KEY2 = Symbol.for("blume.og-cache");
+var registry3 = () => {
+  const host = globalThis;
+  host[REGISTRY_KEY2] ??= { hits: 0, misses: 0, used: new Set };
+  return host[REGISTRY_KEY2];
+};
+var localFontDigests = new Map;
+var inflight = new Map;
+var pruneCardCache = async (dir) => {
+  const { used } = registry3();
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return 0;
+  }
+  const stale = entries.filter((name) => name.endsWith(".tmp") || name.endsWith(".png") && !used.has(name.slice(0, -".png".length)));
+  await Promise.all(stale.map((name) => rm(join4(dir, name), { force: true })));
+  return stale.length;
+};
+var cardCacheTally = () => {
+  const { hits, misses } = registry3();
+  return hits + misses === 0 ? null : { hits, misses };
+};
+
+// src/astro/generate.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync6, readFileSync as readFileSync3, realpathSync } from "node:fs";
+import {
+  lstat,
+  mkdir as mkdir2,
+  readFile as readFile5,
+  readlink,
+  realpath,
+  rm as rm2,
+  symlink
+} from "node:fs/promises";
+import { createRequire as createRequire2 } from "node:module";
+import { pathToFileURL } from "node:url";
+import pMap3 from "p-map";
+import {
+  basename as basename2,
+  dirname as dirname6,
+  isAbsolute as isAbsolute6,
+  join as join11,
+  normalize,
+  relative as relative4,
+  resolve as resolve6
+} from "pathe";
+import { glob as glob3 } from "tinyglobby";
+
+// src/ai/api/problem.ts
+var PROBLEM_TYPE = "application/problem+json";
+
+// src/ai/api/spec.ts
+var JSON_TYPE = "application/json";
+var MARKDOWN_TYPE = "text/markdown";
+var TEXT_TYPE = "text/plain";
+var ref = (name) => ({
+  $ref: `#/components/schemas/${name}`
+});
+var jsonResponse = (description, schema) => ({
+  content: { [JSON_TYPE]: { schema: ref(schema) } },
+  description
+});
+var problemResponse = (description) => ({
+  content: { [PROBLEM_TYPE]: { schema: ref("Problem") } },
+  description
+});
+var textResponse = (description, type) => ({
+  content: { [type]: { schema: { type: "string" } } },
+  description
+});
+var string = (description) => ({ description, type: "string" });
+var facetsSchema = {
+  additionalProperties: { type: "string" },
+  description: "Facet values the site declares for the page's content type (`content.types.<type>.facets`), key → value.",
+  type: "object"
+};
+var versionProperty = {
+  description: 'Docs version the page belongs to on a versioned site: `""` for the current docs, else an archived version id. Absent on unversioned sites.',
+  type: "string"
+};
+var searchParameters = [
+  {
+    description: "The search query.",
+    in: "query",
+    name: "q",
+    required: true,
+    schema: { minLength: 1, type: "string" }
+  },
+  {
+    description: "Maximum hits to return (default 8, at most 20).",
+    in: "query",
+    name: "limit",
+    required: false,
+    schema: { default: 8, maximum: 20, minimum: 1, type: "integer" }
+  },
+  {
+    description: "Only include pages of these content types (frontmatter `type`, e.g. `doc`, `rfc`). Comma-separated or repeated. Omit for every type.",
+    explode: false,
+    in: "query",
+    name: "contentTypes",
+    required: false,
+    schema: { items: { type: "string" }, type: "array" },
+    style: "form"
+  },
+  {
+    description: "Only include pages in this locale (e.g. `fr`). Omit for every language.",
+    in: "query",
+    name: "locale",
+    required: false,
+    schema: { type: "string" }
+  },
+  {
+    description: "Docs version to scope to on a versioned site: `latest` (the default — current docs only), `all`, or an archived version id. Ignored when the site is unversioned.",
+    in: "query",
+    name: "version",
+    required: false,
+    schema: { type: "string" }
+  },
+  {
+    description: "Only include pages matching every facet, as `filters[key]=value` pairs (e.g. `filters[status]=enforced`). Facets are metadata the site declares per content type; the page index shows each page's values.",
+    explode: true,
+    in: "query",
+    name: "filters",
+    required: false,
+    schema: { additionalProperties: { type: "string" }, type: "object" },
+    style: "deepObject"
+  }
+];
+var schemas = {
+  JsonRpcRequest: {
+    description: "A JSON-RPC 2.0 request, as the Model Context Protocol sends.",
+    properties: {
+      id: { description: "Request id (absent on notifications)." },
+      jsonrpc: { const: "2.0", type: "string" },
+      method: string("The MCP method, e.g. `initialize` or `tools/call`."),
+      params: { description: "Method parameters.", type: "object" }
+    },
+    required: ["jsonrpc", "method"],
+    type: "object"
+  },
+  JsonRpcResponse: {
+    description: "A JSON-RPC 2.0 response: a `result` or an `error`.",
+    properties: {
+      error: {
+        properties: {
+          code: { type: "integer" },
+          data: {},
+          message: { type: "string" }
+        },
+        required: ["code", "message"],
+        type: "object"
+      },
+      id: {},
+      jsonrpc: { const: "2.0", type: "string" },
+      result: { type: "object" }
+    },
+    required: ["jsonrpc"],
+    type: "object"
+  },
+  NavLink: {
+    properties: {
+      href: string("Link target — an internal route or an external URL."),
+      icon: string("Optional icon name."),
+      label: { type: "string" }
+    },
+    required: ["href", "label"],
+    type: "object"
+  },
+  NavNode: {
+    description: "A sidebar entry: a page (linking to its route) or a group holding further nodes.",
+    oneOf: [
+      {
+        properties: {
+          badge: { type: "string" },
+          deprecated: { type: "boolean" },
+          description: { type: "string" },
+          icon: { type: "string" },
+          kind: { const: "page", type: "string" },
+          label: { type: "string" },
+          pageId: string("The page's stable content id."),
+          route: string("The page's route.")
+        },
+        required: ["kind", "label", "pageId", "route"],
+        type: "object"
+      },
+      {
+        properties: {
+          badge: { type: "string" },
+          children: { items: ref("NavNode"), type: "array" },
+          collapsed: { type: "boolean" },
+          icon: { type: "string" },
+          kind: { const: "group", type: "string" },
+          label: { type: "string" },
+          path: string("The group's route prefix (not necessarily a page)."),
+          route: string("The group's index page route, when it has one.")
+        },
+        required: ["children", "kind", "label"],
+        type: "object"
+      }
+    ]
+  },
+  NavSelector: {
+    description: "A top-level partition selector (products, versions, languages).",
+    properties: {
+      items: {
+        items: {
+          properties: {
+            description: { type: "string" },
+            label: { type: "string" },
+            path: { type: "string" },
+            tag: { type: "string" }
+          },
+          required: ["label", "path"],
+          type: "object"
+        },
+        type: "array"
+      },
+      kind: { type: "string" },
+      label: { type: "string" }
+    },
+    required: ["items", "kind", "label"],
+    type: "object"
+  },
+  NavTab: {
+    properties: {
+      href: string("The clickable target when it differs from `path` (the section's first page)."),
+      icon: { type: "string" },
+      label: { type: "string" },
+      path: string("The tab's section prefix.")
+    },
+    required: ["label", "path"],
+    type: "object"
+  },
+  Navigation: {
+    description: "The docs navigation model: header tabs, the sidebar tree, partition selectors, and pinned links.",
+    properties: {
+      actions: { items: ref("NavLink"), type: "array" },
+      cta: { oneOf: [ref("NavLink"), { type: "null" }] },
+      featured: { items: ref("NavLink"), type: "array" },
+      repoUrl: { type: ["string", "null"] },
+      root: string("The tree root's route (`/`, or a locale/version prefix)."),
+      selectors: { items: ref("NavSelector"), type: "array" },
+      sidebar: { items: ref("NavNode"), type: "array" },
+      tabs: { items: ref("NavTab"), type: "array" }
+    },
+    required: ["featured", "selectors", "sidebar", "tabs"],
+    type: "object"
+  },
+  Page: {
+    allOf: [
+      ref("PageSummary"),
+      {
+        properties: {
+          markdown: string("The page as agent Markdown: frontmatter included, components downleveled to plain Markdown.")
+        },
+        required: ["markdown"],
+        type: "object"
+      }
+    ],
+    description: "A page's index entry plus its full Markdown body."
+  },
+  PageSummary: {
+    properties: {
+      contentType: string("The page's content type (frontmatter `type`)."),
+      description: { type: "string" },
+      facets: facetsSchema,
+      json: {
+        description: "This page's JSON representation (the `getPage` operation).",
+        format: "uri-reference",
+        type: "string"
+      },
+      lastModified: {
+        description: "ISO 8601 last-modified date, when known.",
+        type: ["string", "null"]
+      },
+      locale: string("The page's locale code."),
+      markdownUrl: {
+        description: "The page's raw-Markdown mirror (the `getPageMarkdown` operation).",
+        format: "uri-reference",
+        type: "string"
+      },
+      route: string("The page's route (`/guides/install`); the key every other operation takes."),
+      title: { type: "string" },
+      url: {
+        description: "Where the rendered page is served.",
+        format: "uri-reference",
+        type: "string"
+      },
+      version: versionProperty
+    },
+    required: [
+      "contentType",
+      "json",
+      "lastModified",
+      "locale",
+      "markdownUrl",
+      "route",
+      "title",
+      "url"
+    ],
+    type: "object"
+  },
+  PagesIndex: {
+    properties: {
+      count: { type: "integer" },
+      generator: string("The Blume version that built the site."),
+      pages: { items: ref("PageSummary"), type: "array" },
+      site: { type: ["string", "null"] }
+    },
+    required: ["count", "generator", "pages", "site"],
+    type: "object"
+  },
+  Problem: {
+    description: "RFC 9457 problem details, with a stable code and a resolution hint.",
+    properties: {
+      code: string("Stable error code (e.g. `PAGE_NOT_FOUND`)."),
+      detail: string("Human-readable explanation of this occurrence."),
+      instance: string("The request path the problem occurred on."),
+      links: {
+        description: "Recovery links, when there is somewhere useful to go.",
+        items: {
+          properties: { href: { type: "string" }, label: { type: "string" } },
+          required: ["href", "label"],
+          type: "object"
+        },
+        type: "array"
+      },
+      resolution: string("What to do next."),
+      status: { type: "integer" },
+      title: { type: "string" },
+      type: string("Problem type URI; `about:blank` by default.")
+    },
+    required: ["code", "detail", "resolution", "status", "title", "type"],
+    type: "object"
+  },
+  SearchHit: {
+    properties: {
+      contentType: { type: "string" },
+      excerpt: string("The page description, else the start of its content."),
+      facets: facetsSchema,
+      route: string("The page's route; pass it to `getPage`."),
+      title: { type: "string" },
+      url: { format: "uri-reference", type: "string" },
+      version: versionProperty
+    },
+    required: ["excerpt", "route", "title", "url"],
+    type: "object"
+  },
+  SearchResponse: {
+    properties: {
+      count: { type: "integer" },
+      query: { type: "string" },
+      results: { items: ref("SearchHit"), type: "array" }
+    },
+    required: ["count", "query", "results"],
+    type: "object"
+  }
+};
+var ROUTE_PARAM = {
+  description: "The page route without its leading slash (`guides/install`), or `index` for the home page. May contain slashes.",
+  in: "path",
+  name: "route",
+  required: true,
+  schema: { type: "string" }
+};
+var serverUrl = (input) => {
+  if (input.site) {
+    return input.base ? absoluteUrl(input.site, input.base) : siteRoot(input.site);
+  }
+  return input.base || "/";
+};
+var buildApiSpec = (input) => {
+  const pathEntries = [
+    [
+      API_PAGES_PATH,
+      {
+        get: {
+          description: "Every documentation page with its route, title, description, content type, locale, facets, and the URLs of its rendered, Markdown, and JSON forms. Unfiltered; on a versioned site every version is listed with its `version`. Use it to enumerate the docs or to find a page when search is too narrow.",
+          operationId: "listPages",
+          responses: {
+            "200": jsonResponse("The page index.", "PagesIndex"),
+            default: problemResponse("An error, as problem details.")
+          },
+          summary: "List every page",
+          tags: ["Pages"]
+        }
+      }
+    ],
+    [
+      API_PAGE_PATH,
+      {
+        get: {
+          description: "A single page as JSON: its index entry plus the page's agent Markdown (frontmatter included, components downleveled to plain Markdown). Take `route` from `listPages` or `searchDocs`.",
+          operationId: "getPage",
+          parameters: [ROUTE_PARAM],
+          responses: {
+            "200": jsonResponse("The page.", "Page"),
+            "404": problemResponse("No page has that route."),
+            default: problemResponse("An error, as problem details.")
+          },
+          summary: "Get a page as JSON",
+          tags: ["Pages"]
+        }
+      }
+    ],
+    [
+      API_NAVIGATION_PATH,
+      {
+        get: {
+          description: "The navigation tree (header tabs and the sidebar hierarchy) as readers see it, for the default locale and the current docs.",
+          operationId: "getNavigation",
+          responses: {
+            "200": jsonResponse("The navigation tree.", "Navigation"),
+            default: problemResponse("An error, as problem details.")
+          },
+          summary: "Get the navigation tree",
+          tags: ["Navigation"]
+        }
+      }
+    ]
+  ];
+  if (input.search) {
+    pathEntries.push([
+      API_SEARCH_PATH,
+      {
+        get: {
+          description: "Full-text search across the documentation. Returns matching pages with their title, route, content type, and a short excerpt; narrow by content type, locale, version, or facet. Use it first to discover relevant pages, then `getPage` to read one in full.",
+          operationId: "searchDocs",
+          parameters: searchParameters,
+          responses: {
+            "200": jsonResponse("The matching pages, best first.", "SearchResponse"),
+            "400": problemResponse("The query was missing or blank."),
+            default: problemResponse("An error, as problem details.")
+          },
+          summary: "Search the docs",
+          tags: ["Search"]
+        }
+      }
+    ]);
+  }
+  pathEntries.push([
+    "/{route}.md",
+    {
+      get: {
+        description: "A page's raw-Markdown mirror: append `.md` to any page URL. Components are downleveled to plain Markdown; `.mdx` serves the source as written. The same body the `getPage` operation carries in its `markdown` field.",
+        operationId: "getPageMarkdown",
+        parameters: [ROUTE_PARAM],
+        responses: {
+          "200": textResponse("The page as Markdown.", MARKDOWN_TYPE),
+          "404": textResponse("No page has that route; the body lists where to look next.", MARKDOWN_TYPE)
+        },
+        summary: "Get a page as Markdown",
+        tags: ["Markdown"]
+      }
+    }
+  ]);
+  if (input.llmsTxt) {
+    pathEntries.push([
+      "/llms.txt",
+      {
+        get: {
+          description: "The llms.txt index: the site's summary, when to use it, and every page with a one-line description, grouped by section.",
+          operationId: "getLlmsTxt",
+          responses: {
+            "200": textResponse("The index.", TEXT_TYPE)
+          },
+          summary: "Get llms.txt",
+          tags: ["Markdown"]
+        }
+      }
+    ], [
+      "/llms-full.txt",
+      {
+        get: {
+          description: "The full Markdown of every current-docs page in one file.",
+          operationId: "getLlmsFullTxt",
+          responses: {
+            "200": textResponse("Every page's Markdown.", TEXT_TYPE)
+          },
+          summary: "Get llms-full.txt",
+          tags: ["Markdown"]
+        }
+      }
+    ]);
+  }
+  if (input.agentReadability) {
+    pathEntries.push([
+      "/agent-readability.json",
+      {
+        get: {
+          description: "A manifest indexing every agent-facing artifact the site publishes — this API, the Markdown mirrors, llms.txt, the MCP server, feeds, and the sitemap.",
+          operationId: "getAgentReadability",
+          responses: {
+            "200": {
+              content: { [JSON_TYPE]: { schema: { type: "object" } } },
+              description: "The manifest."
+            }
+          },
+          summary: "Get the agent-readability manifest",
+          tags: ["Discovery"]
+        }
+      }
+    ]);
+  }
+  if (input.mcpRoute) {
+    pathEntries.push([
+      input.mcpRoute,
+      {
+        post: {
+          description: "The Model Context Protocol server (Streamable HTTP, stateless, JSON responses). Tools: `search_docs`, `get_page`, `list_pages`, `get_navigation` — the same operations this API exposes — plus every page as a `text/markdown` resource. Discovery document at `/.well-known/mcp.json`.",
+          operationId: "mcp",
+          requestBody: {
+            content: { [JSON_TYPE]: { schema: ref("JsonRpcRequest") } },
+            required: true
+          },
+          responses: {
+            "200": jsonResponse("The JSON-RPC response.", "JsonRpcResponse")
+          },
+          summary: "Call the MCP server",
+          tags: ["MCP"]
+        }
+      }
+    ]);
+  }
+  const tags = [
+    { description: "Enumerate and read documentation pages.", name: "Pages" },
+    ...input.search ? [{ description: "Full-text search over the docs.", name: "Search" }] : [],
+    { description: "How the docs are organized.", name: "Navigation" },
+    { description: "Plain-text and Markdown surfaces.", name: "Markdown" },
+    ...input.agentReadability ? [{ description: "Agent discovery documents.", name: "Discovery" }] : [],
+    ...input.mcpRoute ? [{ description: "The Model Context Protocol endpoint.", name: "MCP" }] : []
+  ];
+  const info = {
+    description: [
+      `Read-only JSON API over the ${input.name} documentation${input.description ? `: ${input.description}` : "."}`,
+      "Every operation is public and needs no authentication. Errors are RFC 9457 problem details (`application/problem+json`) with a stable `code`, a `detail`, and a `resolution` hint."
+    ].join(`
+
+`),
+    title: apiNamePhrase(input.name),
+    version: input.version,
+    "x-generator": `blume@${input.version}`
+  };
+  const document = {
+    components: { schemas },
+    info,
+    openapi: "3.1.0",
+    paths: Object.fromEntries(pathEntries),
+    security: [],
+    servers: [{ description: input.name, url: serverUrl(input) }],
+    tags
+  };
+  if (input.site) {
+    document.externalDocs = {
+      description: `${input.name} documentation`,
+      url: absoluteUrl(input.site, withBasePath(input.base, "/"))
+    };
+  }
+  return document;
+};
+
+// src/ai/ask-data.ts
+var buildAskData = async (project) => {
+  const documents = await buildSearchDocuments(project, {
+    audience: "agents",
+    content: "markdown",
+    includeWhenDisabled: true
+  });
+  return {
+    defaultLocale: project.config.i18n?.defaultLocale,
+    documents: documents.map((doc) => ({
+      content: doc.content,
+      description: doc.description,
+      locale: doc.locale,
+      route: doc.route,
+      title: doc.title
+    })),
+    site: project.config.deployment.site ?? null
+  };
+};
+
+// src/ai/mcp/discovery.ts
+var serverUrl2 = (input) => {
+  const path = withBasePath(input.base, input.route);
+  return input.site ? absoluteUrl(input.site, path) : path;
+};
+var buildMcpDiscovery = (input) => ({
+  servers: [
+    {
+      name: input.name,
+      transport: "streamable-http",
+      url: serverUrl2(input)
+    }
+  ]
+});
+var SERVER_CARD_SCHEMA = "https://static.modelcontextprotocol.io/schemas/v1/server-card.schema.json";
+var CARD_TEXT_MAX = 100;
+var truncate = (text) => text.length > CARD_TEXT_MAX ? `${text.slice(0, CARD_TEXT_MAX - 1)}…` : text;
+var NON_ASCII_SLUG = /[^a-z0-9]+/gu;
+var COMBINING_MARKS = /\p{M}+/gu;
+var asciiSlugify = (text) => trimChar(text.normalize("NFKD").replace(COMBINING_MARKS, "").toLowerCase().replace(NON_ASCII_SLUG, "-"), "-");
+var reverseDnsName = (input) => {
+  let namespace = "localhost";
+  if (input.site) {
+    try {
+      namespace = new URL(input.site).hostname.split(".").toReversed().join(".");
+    } catch {}
+  }
+  return `${namespace}/${asciiSlugify(input.name) || "docs"}`;
+};
+var HTTP_URL = /^https?:\/\//u;
+var buildMcpServerCard = (input) => {
+  const url = serverUrl2(input);
+  const card = {
+    $schema: SERVER_CARD_SCHEMA,
+    capabilities: {
+      resources: { listChanged: false, subscribe: false },
+      tools: { listChanged: false }
+    },
+    description: truncate(`Model Context Protocol server for the ${input.name} documentation.`),
+    name: reverseDnsName(input),
+    serverInfo: { name: input.name, version: input.version },
+    title: truncate(input.name),
+    tools: MCP_TOOLS.map((tool) => ({
+      annotations: tool.annotations,
+      description: tool.description,
+      name: tool.name,
+      title: tool.title
+    })),
+    transport: "streamable-http",
+    transports: [{ endpoint: url, type: "streamable-http" }],
+    url,
+    version: input.version
+  };
+  if (HTTP_URL.test(url)) {
+    card.remotes = [{ type: "streamable-http", url }];
+  }
+  if (input.site) {
+    card.websiteUrl = siteRoot(input.site);
+  }
+  return card;
+};
+
+// src/components/layout/nav-utils.ts
+var hasDeferrableGroups = (sidebar) => sidebar.some((node) => node.kind === "group" && ((node.display ?? "flat") !== "flat" || hasDeferrableGroups(node.children)));
+var navVariants = (data) => [
+  { locale: "default", navigation: data.navigation, version: "current" },
+  ...Object.entries(data.navigationByLocale).map(([locale, navigation]) => ({
+    locale,
+    navigation,
+    version: "current"
+  })),
+  ...Object.entries(data.navigationByVersion).flatMap(([version, byLocale]) => Object.entries(byLocale).map(([locale, navigation]) => ({
+    locale: locale || "default",
+    navigation,
+    version
+  })))
+];
+
+// src/core/builtin-tags.ts
+var BUILTIN_MDX_TAGS = new Set([
+  "Accordion",
+  "AccordionItem",
+  "ApiOverview",
+  "ApiTagOperations",
+  "AutoTypeTable",
+  "Badge",
+  "Callout",
+  "Card",
+  "CardGroup",
+  "CodeBlock",
+  "CodeGroup",
+  "Color",
+  "Column",
+  "Columns",
+  "Component",
+  "Diff",
+  "Expandable",
+  "FileTree",
+  "Frame",
+  "GithubInfo",
+  "Icon",
+  "Math",
+  "Operation",
+  "Panel",
+  "Prompt",
+  "Step",
+  "Steps",
+  "Tab",
+  "Tabs",
+  "Tile",
+  "Tooltip",
+  "Tree",
+  "TypeTable",
+  "Visibility",
+  "YouTube"
+]);
+
+// src/core/component-diagnostics.ts
+var toKebab = (tag) => tag.replaceAll(/(?<lower>[a-z0-9])(?<upper>[A-Z])/gu, "$<lower>-$<upper>").toLowerCase();
+var validateUsedComponents = (pages, extraTags, registryNames) => {
+  const diagnostics = [];
+  const seen = new Set;
+  for (const page of pages) {
+    for (const tag of page.componentsUsed ?? []) {
+      if (BUILTIN_MDX_TAGS.has(tag) || extraTags.has(tag) || seen.has(tag)) {
+        continue;
+      }
+      seen.add(tag);
+      const name = toKebab(tag);
+      const suggestion = registryNames.has(name) ? `Run \`blume add ${name}\` to install it, or register <${tag}> in components.ts (mdx).` : `Register <${tag}> in components.ts (mdx), or add an islands/${tag}.tsx component.`;
+      diagnostics.push({
+        code: "BLUME_UNKNOWN_COMPONENT",
+        file: page.sourcePath ?? page.id,
+        message: `<${tag}> is used in ${page.route} but isn't a known component.`,
+        severity: "warning",
+        suggestion
+      });
+    }
+  }
+  return diagnostics;
+};
+
+// src/core/component-overrides.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname3, extname, isAbsolute, resolve as resolve3 } from "pathe";
+import ts from "typescript";
+var GROUPS = ["mdx", "layout", "islands"];
+var GROUP_SET = new Set(GROUPS);
+var isGroup = (name) => GROUP_SET.has(name);
+var FRAMEWORK_BY_EXT = new Map([
+  ["jsx", "react"],
+  ["svelte", "svelte"],
+  ["tsx", "react"],
+  ["vue", "vue"]
+]);
+var FRAMEWORK_LABEL = {
+  react: "React",
+  svelte: "Svelte",
+  vue: "Vue"
+};
+var COMPONENT_EXTS = [
+  "astro",
+  "tsx",
+  "ts",
+  "jsx",
+  "js",
+  "mjs",
+  "vue",
+  "svelte"
+];
+var HYDRATION_MODES = new Set([
+  "idle",
+  "load",
+  "media",
+  "only",
+  "visible"
+]);
+var isHydrationMode = (value) => HYDRATION_MODES.has(value);
+var emptyAnalysis = () => ({
+  islands: [],
+  layout: [],
+  mdx: [],
+  warnings: []
+});
+var propName = (name) => ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : undefined;
+var addImportBindings = (map, statement) => {
+  if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) {
+    return;
+  }
+  const specifier = statement.moduleSpecifier.text;
+  const clause = statement.importClause;
+  if (!clause) {
+    return;
+  }
+  if (clause.name) {
+    map.set(clause.name.text, { imported: "default", specifier });
+  }
+  const named = clause.namedBindings;
+  if (named && ts.isNamedImports(named)) {
+    for (const element of named.elements) {
+      map.set(element.name.text, {
+        imported: (element.propertyName ?? element.name).text,
+        specifier
+      });
+    }
+  }
+};
+var collectImports = (sourceFile) => {
+  const map = new Map;
+  for (const statement of sourceFile.statements) {
+    addImportBindings(map, statement);
+  }
+  return map;
+};
+var unwrapObject = (expression) => {
+  if (ts.isObjectLiteralExpression(expression)) {
+    return expression;
+  }
+  if (ts.isCallExpression(expression)) {
+    const [arg] = expression.arguments;
+    return arg && ts.isObjectLiteralExpression(arg) ? arg : undefined;
+  }
+  if (ts.isAsExpression(expression) || ts.isParenthesizedExpression(expression)) {
+    return unwrapObject(expression.expression);
+  }
+  return;
+};
+var findDefaultExportObject = (sourceFile) => {
+  for (const statement of sourceFile.statements) {
+    if (ts.isExportAssignment(statement) && !statement.isExportEquals) {
+      return unwrapObject(statement.expression);
+    }
+  }
+  return;
+};
+var probeExtension = (base) => {
+  for (const extension of COMPONENT_EXTS) {
+    const candidate = `${base}.${extension}`;
+    if (existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+};
+var toImport = (specifier, imported, dir) => {
+  const relative2 = specifier.startsWith(".") || isAbsolute(specifier);
+  let path = specifier;
+  let extension = extname(specifier).slice(1).toLowerCase();
+  if (relative2) {
+    const absolute = isAbsolute(specifier) ? specifier : resolve3(dir, specifier);
+    if (extension) {
+      path = absolute;
+    } else {
+      const probed = probeExtension(absolute);
+      path = probed ?? absolute;
+      extension = probed ? extname(probed).slice(1).toLowerCase() : "";
+    }
+  }
+  return {
+    framework: FRAMEWORK_BY_EXT.get(extension) ?? null,
+    name: imported,
+    path
+  };
+};
+var resolveIdentifier = (name, imports, dir) => {
+  const binding = imports.get(name);
+  return binding ? toImport(binding.specifier, binding.imported, dir) : null;
+};
+var applyDescriptorProperty = (descriptor, property, imports, dir) => {
+  if (ts.isShorthandPropertyAssignment(property)) {
+    if (property.name.text === "component") {
+      descriptor.hadComponent = true;
+      descriptor.source = resolveIdentifier(property.name.text, imports, dir);
+    }
+    return;
+  }
+  if (!ts.isPropertyAssignment(property)) {
+    return;
+  }
+  const name = propName(property.name);
+  const init = property.initializer;
+  if (name === "component") {
+    descriptor.hadComponent = true;
+    if (ts.isStringLiteral(init)) {
+      descriptor.source = toImport(init.text, "default", dir);
+    } else if (ts.isIdentifier(init)) {
+      descriptor.source = resolveIdentifier(init.text, imports, dir);
+    }
+  } else if (name === "client" && ts.isStringLiteral(init) && isHydrationMode(init.text)) {
+    descriptor.client = init.text;
+  } else if (name === "media" && ts.isStringLiteral(init)) {
+    descriptor.media = init.text;
+  }
+};
+var readDescriptor = (object, imports, dir) => {
+  const descriptor = { hadComponent: false, source: null };
+  for (const property of object.properties) {
+    applyDescriptorProperty(descriptor, property, imports, dir);
+  }
+  return descriptor;
+};
+var finalize = (key, group, descriptor, label, identifier, warnings) => {
+  const { client, media, source } = descriptor;
+  if (group === "islands") {
+    if (!source) {
+      warnings.push(`Island override "${key}" couldn't be resolved to a file. Reference it by an imported component or a path string with an extension.`);
+      return null;
+    }
+    if (!source.framework) {
+      warnings.push(`Island override "${key}" (${label}) is not a React, Vue, or Svelte component; only framework components can be islands.`);
+      return null;
+    }
+  }
+  if (client === "media" && !media) {
+    warnings.push(`Override "${key}" uses client: "media" but no \`media\` query was given; it will hydrate as if \`client: "load"\`.`);
+  }
+  if (client === "only" && source && !source.framework) {
+    warnings.push(`Override "${key}" uses client: "only" but its framework couldn't be inferred; reference a .tsx/.jsx/.vue/.svelte file.`);
+  }
+  if (!client && source?.framework) {
+    warnings.push(`Override "${key}" points to a ${FRAMEWORK_LABEL[source.framework]} component (${label}) but has no hydration mode, so it renders as static HTML with no interactivity. Add one, e.g. \`${key}: { component: ${JSON.stringify(label)}, client: "load" }\`.`);
+  }
+  const normalized = { identifier, key, source };
+  if (client) {
+    normalized.client = client;
+  }
+  if (media) {
+    normalized.media = media;
+  }
+  return normalized;
+};
+var normalizeEntry = (entry, group, imports, dir, warnings) => {
+  const defaultClient = group === "islands" ? "visible" : undefined;
+  if (ts.isShorthandPropertyAssignment(entry)) {
+    const name = entry.name.text;
+    return finalize(name, group, {
+      client: defaultClient,
+      hadComponent: true,
+      source: resolveIdentifier(name, imports, dir)
+    }, name, true, warnings);
+  }
+  if (!ts.isPropertyAssignment(entry)) {
+    return null;
+  }
+  const key = propName(entry.name);
+  if (!key) {
+    return null;
+  }
+  const value = entry.initializer;
+  if (ts.isIdentifier(value)) {
+    return finalize(key, group, {
+      client: defaultClient,
+      hadComponent: true,
+      source: resolveIdentifier(value.text, imports, dir)
+    }, value.text, true, warnings);
+  }
+  if (ts.isStringLiteral(value)) {
+    return finalize(key, group, {
+      client: defaultClient,
+      hadComponent: true,
+      source: toImport(value.text, "default", dir)
+    }, value.text, false, warnings);
+  }
+  if (ts.isObjectLiteralExpression(value)) {
+    const descriptor = readDescriptor(value, imports, dir);
+    if (!descriptor.hadComponent) {
+      warnings.push(`Override "${key}" is an object without a \`component\` field; expected \`{ component, client }\`.`);
+      return null;
+    }
+    if (!descriptor.source) {
+      warnings.push(`Override "${key}"'s \`component\` couldn't be resolved to a file. Reference an imported component or a path string with an extension.`);
+      return null;
+    }
+    return finalize(key, group, { ...descriptor, client: descriptor.client ?? defaultClient }, key, false, warnings);
+  }
+  return { identifier: false, key, source: null };
+};
+var collectGroupOverrides = (property, imports, dir, result) => {
+  if (!ts.isPropertyAssignment(property)) {
+    return;
+  }
+  const name = propName(property.name);
+  if (!(name && isGroup(name)) || !ts.isObjectLiteralExpression(property.initializer)) {
+    return;
+  }
+  for (const entry of property.initializer.properties) {
+    const normalized = normalizeEntry(entry, name, imports, dir, result.warnings);
+    if (normalized) {
+      result[name].push(normalized);
+    }
+  }
+};
+var analyzeComponentOverrides = (source, filePath) => {
+  const result = emptyAnalysis();
+  const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, filePath.endsWith("tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  const object = findDefaultExportObject(sourceFile);
+  if (!object) {
+    return result;
+  }
+  const imports = collectImports(sourceFile);
+  const dir = dirname3(filePath);
+  for (const property of object.properties) {
+    collectGroupOverrides(property, imports, dir, result);
+  }
+  return result;
+};
+
+// src/core/svg-dimensions.ts
+var ROOT = /<svg\s(?:[^>"']|"[^"]*"|'[^']*')*>/u;
+var WIDTH = /\swidth=(?<quote>['"])(?<value>[^%]+?)\k<quote>/u;
+var HEIGHT = /\sheight=(?<quote>['"])(?<value>[^%]+?)\k<quote>/u;
+var VIEWBOX = /\sviewBox=(?<quote>['"])(?<value>.+?)\k<quote>/iu;
+var INCH_CM = 2.54;
+var UNITS = new Map([
+  ["cm", 96 / INCH_CM],
+  ["em", 16],
+  ["ex", 8],
+  ["in", 96],
+  ["m", 96 / INCH_CM * 100],
+  ["mm", 96 / INCH_CM / 10],
+  ["pc", 96 / 72 * 12],
+  ["pt", 96 / 72],
+  ["px", 1]
+]);
+var LENGTH = /^(?<number>[0-9.]+(?:e\d+)?)(?<unit>in|cm|em|ex|m|mm|pc|pt|px)?$/u;
+var parseLength = (value) => {
+  const groups = value === undefined ? undefined : LENGTH.exec(value)?.groups;
+  if (!groups) {
+    return;
+  }
+  const pixels = Math.round(Number(groups.number) * (UNITS.get(groups.unit ?? "px") ?? 1));
+  return pixels > 0 ? pixels : undefined;
+};
+var attribute = (root, pattern) => pattern.exec(root)?.groups?.value;
+var viewBoxSize = (root) => {
+  const raw = attribute(root, VIEWBOX);
+  if (raw === undefined) {
+    return null;
+  }
+  const bounds = raw.split(" ");
+  const width = parseLength(bounds[2]);
+  const height = parseLength(bounds[3]);
+  return width && height ? { height, width } : null;
+};
+var svgDimensions = (svg) => {
+  const root = ROOT.exec(svg)?.[0];
+  if (root === undefined) {
+    return null;
+  }
+  const width = parseLength(attribute(root, WIDTH));
+  const height = parseLength(attribute(root, HEIGHT));
+  if (width && height) {
+    return { height, width };
+  }
+  const box = viewBoxSize(root);
+  if (!box) {
+    return null;
+  }
+  const ratio = box.width / box.height;
+  if (width) {
+    const scaled = Math.floor(width / ratio);
+    return scaled > 0 ? { height: scaled, width } : null;
+  }
+  if (height) {
+    const scaled = Math.floor(height * ratio);
+    return scaled > 0 ? { height, width: scaled } : null;
+  }
+  return box;
+};
+
+// src/core/tsconfig-aliases.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname4, join as join5, resolve as resolve4 } from "pathe";
+import ts2 from "typescript";
+var PARSE_HOST = {
+  fileExists: ts2.sys.fileExists,
+  readDirectory: () => [],
+  readFile: ts2.sys.readFile,
+  useCaseSensitiveFileNames: ts2.sys.useCaseSensitiveFileNames
+};
+var isPathTarget = (target) => typeof target === "string";
+var toAlias = (key, value, baseDir) => {
+  const [first] = value;
+  if (!isPathTarget(first)) {
+    return null;
+  }
+  const find = key.endsWith("/*") ? key.slice(0, -2) : key;
+  const target = first.endsWith("/*") ? first.slice(0, -2) : first;
+  if (find === "" || find === "*") {
+    return null;
+  }
+  return { find, replacement: resolve4(baseDir, target) };
+};
+var resolveTsconfigAliases = (root) => {
+  const entry = ["tsconfig.json", "jsconfig.json"].map((name) => join5(root, name)).find((file) => existsSync3(file));
+  if (!entry) {
+    return {};
+  }
+  const { config, error } = ts2.readConfigFile(entry, ts2.sys.readFile);
+  if (error) {
+    return {};
+  }
+  const configDir = dirname4(entry);
+  const { options } = ts2.parseJsonConfigFileContent(config, PARSE_HOST, configDir, undefined, entry);
+  const { paths } = options;
+  if (!paths) {
+    return {};
+  }
+  const { pathsBasePath } = options;
+  const baseDir = options.baseUrl ?? pathsBasePath ?? configDir;
+  const entries = [];
+  for (const [key, value] of Object.entries(paths)) {
+    const alias = toAlias(key, value, baseDir);
+    if (alias) {
+      entries.push([alias.find, alias.replacement]);
+    }
+  }
+  return Object.fromEntries(entries);
+};
+
+// src/markdown/language-icon.ts
+import {
+  siAstro,
+  siC,
+  siCplusplus,
+  siCss,
+  siDart,
+  siDocker,
+  siGnubash,
+  siGo,
+  siGraphql,
+  siHtml5,
+  siJavascript,
+  siJson,
+  siKotlin,
+  siLess,
+  siLua,
+  siMarkdown,
+  siMdx,
+  siMysql,
+  siNextdotjs,
+  siPhp,
+  siPrisma,
+  siPython,
+  siReact,
+  siRuby,
+  siRust,
+  siSass,
+  siScala,
+  siSvelte,
+  siSvg,
+  siSwift,
+  siToml,
+  siTypescript,
+  siVuedotjs,
+  siWebassembly,
+  siYaml
+} from "simple-icons";
+var LANGUAGE_ICONS = {
+  astro: siAstro,
+  bash: siGnubash,
+  c: siC,
+  "c++": siCplusplus,
+  cjs: siJavascript,
+  cpp: siCplusplus,
+  css: siCss,
+  cts: siTypescript,
+  dart: siDart,
+  docker: siDocker,
+  dockerfile: siDocker,
+  go: siGo,
+  gql: siGraphql,
+  graphql: siGraphql,
+  html: siHtml5,
+  javascript: siJavascript,
+  js: siJavascript,
+  json: siJson,
+  json5: siJson,
+  jsonc: siJson,
+  jsx: siReact,
+  kotlin: siKotlin,
+  kt: siKotlin,
+  less: siLess,
+  lua: siLua,
+  markdown: siMarkdown,
+  md: siMarkdown,
+  mdx: siMdx,
+  mjs: siJavascript,
+  mts: siTypescript,
+  nextjs: siNextdotjs,
+  php: siPhp,
+  prisma: siPrisma,
+  py: siPython,
+  python: siPython,
+  rb: siRuby,
+  react: siReact,
+  rs: siRust,
+  ruby: siRuby,
+  rust: siRust,
+  sass: siSass,
+  scala: siScala,
+  scss: siSass,
+  sh: siGnubash,
+  shell: siGnubash,
+  sql: siMysql,
+  svelte: siSvelte,
+  svg: siSvg,
+  swift: siSwift,
+  toml: siToml,
+  ts: siTypescript,
+  tsx: siReact,
+  typescript: siTypescript,
+  vue: siVuedotjs,
+  wasm: siWebassembly,
+  yaml: siYaml,
+  yml: siYaml,
+  zsh: siGnubash
+};
+var languageIconSlug = (language) => LANGUAGE_ICONS[language.toLowerCase()]?.slug ?? null;
+var FENCE_LANGUAGE = /^[ \t]*(?:`{3,}|~{3,})[ \t]*(?<lang>[\w+#.-]+)/gmu;
+var PROP_LANGUAGE = /\blang(?:uage)?=["'](?<lang>[\w+#.-]+)["']/gu;
+var languageIconSlugsIn = (markdown) => {
+  const slugs = new Set;
+  for (const pattern of [FENCE_LANGUAGE, PROP_LANGUAGE]) {
+    for (const match of markdown.matchAll(pattern)) {
+      const slug = languageIconSlug(match.groups?.lang ?? "");
+      if (slug) {
+        slugs.add(slug);
+      }
+    }
+  }
+  return [...slugs].toSorted();
+};
+var iconBySlug = (slug) => Object.values(LANGUAGE_ICONS).find((icon) => icon.slug === slug);
+var maskUri = (path) => `url("data:image/svg+xml,${encodeURIComponent(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="${path}"/></svg>`)}")`;
+var languageIconCss = (slugs) => slugs.map((slug) => {
+  const icon = iconBySlug(slug);
+  if (!icon) {
+    return "";
+  }
+  const mask = maskUri(icon.path);
+  return `.prose > :where(pre[data-language][data-icon="${slug}"])::after {
+  background-color: var(--blume-muted-foreground);
+  -webkit-mask-image: ${mask};
+  mask-image: ${mask};
+}`;
+}).filter((rule) => rule !== "").join(`
+`);
+
+// src/markdown/mermaid.ts
+var MERMAID_FENCE = /^[ \t]*(?:`{3,}|~{3,})[ \t]*mermaid\b/mu;
+var hasMermaidFence = (text) => MERMAID_FENCE.test(text);
+
+// src/og/derive.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join6 } from "pathe";
+var CARD_WEIGHTS = [400, 600];
+var absoluteSrc = (root, src) => isAbsolute2(src) ? src : join6(root, src);
+var isNumericWeight = (weight) => typeof weight === "number";
+var isRangeWeight = (weight) => typeof weight === "string";
+var isFontName = (value) => typeof value === "string";
+var isLocalOgFont = (font) => typeof font !== "string" && ("src" in font);
+var googleWeights = (weights) => {
+  const numbers = weights.filter(isNumericWeight);
+  const used = numbers.filter((weight) => CARD_WEIGHTS.includes(weight));
+  if (used.length > 0) {
+    return used;
+  }
+  if (numbers.length > 0) {
+    return numbers;
+  }
+  const [first] = weights;
+  return weights.length === 1 && isRangeWeight(first) ? first : undefined;
+};
+var googleOgFont = (name, weights) => {
+  const weight = googleWeights(weights);
+  return weight === undefined ? { name } : { name, weight };
+};
+var localOgFonts = (font, root) => font.variants.map((variant) => {
+  const entry = {
+    name: font.name,
+    src: absoluteSrc(root, variant.src)
+  };
+  const withWeight = isNumericWeight(variant.weight) ? { ...entry, weight: variant.weight } : entry;
+  return variant.style === "normal" || variant.style === "italic" ? { ...withWeight, style: variant.style } : withWeight;
+});
+var roleFonts = (value, root) => {
+  if (isFontName(value)) {
+    if (!isFontSlug(value)) {
+      return null;
+    }
+    const def = GOOGLE_FONTS[value];
+    return [googleOgFont(def.family, def.weights)];
+  }
+  if ("variants" in value) {
+    return localOgFonts(value, root);
+  }
+  if ((value.provider ?? "google") !== "google") {
+    return null;
+  }
+  return [googleOgFont(value.name, value.weights ?? CARD_WEIGHTS)];
+};
+var roleFamily = (value) => {
+  if (isFontName(value)) {
+    return isFontSlug(value) ? GOOGLE_FONTS[value].family : null;
+  }
+  return value.name;
+};
+var deriveOgFonts = (fonts, root) => {
+  const derived = [];
+  const seen = new Set;
+  const families = {};
+  const roles = [
+    ["title", fonts?.display],
+    ["body", fonts?.body]
+  ];
+  for (const [role, value] of roles) {
+    if (value === undefined) {
+      continue;
+    }
+    const roleEntries = roleFonts(value, root);
+    if (!roleEntries) {
+      continue;
+    }
+    families[role] = roleFamily(value) ?? undefined;
+    for (const entry of roleEntries) {
+      const key = JSON.stringify(entry);
+      if (!seen.has(key)) {
+        seen.add(key);
+        derived.push(entry);
+      }
+    }
+  }
+  const result = { fonts: derived };
+  if (families.title || families.body) {
+    result.families = families;
+  }
+  return result;
+};
+var resolveOgFontSources = (fonts, root) => fonts.map((font) => isLocalOgFont(font) ? { ...font, src: absoluteSrc(root, font.src) } : font);
+var resolveOgFonts = (options, root) => {
+  if (options.ogFonts) {
+    return { fonts: resolveOgFontSources(options.ogFonts, root) };
+  }
+  return options.themeFontsConfigured ? deriveOgFonts(options.themeFonts, root) : { fonts: [] };
+};
+var missingFontFiles = (options, root) => {
+  const sources = [];
+  for (const value of Object.values(options.themeFonts ?? {})) {
+    if (!isFontName(value) && "variants" in value) {
+      sources.push(...value.variants.map((variant) => absoluteSrc(root, variant.src)));
+    }
+  }
+  for (const font of options.ogFonts) {
+    if (isLocalOgFont(font)) {
+      sources.push(absoluteSrc(root, font.src));
+    }
+  }
+  return [...new Set(sources)].filter((path) => !existsSync4(path));
+};
+
+// src/og/logo.ts
+import { existsSync as existsSync5, readFileSync } from "node:fs";
+import { join as join7 } from "pathe";
+var resolveOgLogo = (project, source) => {
+  if (!source?.toLowerCase().endsWith(".svg")) {
+    return;
+  }
+  const relative2 = source.replace(/^\//u, "");
+  const file = [
+    join7(project.context.root, "public", relative2),
+    join7(project.context.root, relative2)
+  ].find((path) => existsSync5(path));
+  return file ? readFileSync(file, "utf-8") : undefined;
+};
+
+// src/openapi/scalar.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join8 } from "pathe";
+
+// src/theme/palette.ts
+var FALLBACK_ACCENT = "oklch(0.62 0.16 250)";
+var ACCENTS = {
+  blue: FALLBACK_ACCENT,
+  green: "oklch(0.6 0.16 150)",
+  orange: "oklch(0.68 0.17 50)",
+  pink: "oklch(0.65 0.2 350)",
+  purple: "oklch(0.58 0.2 290)",
+  red: "oklch(0.58 0.22 25)",
+  teal: "oklch(0.6 0.12 195)"
+};
+var isAccentPreset = (value) => Object.hasOwn(ACCENTS, value);
+var CSS_COLOR = /^[\w\s#%.,()/+-]+$/u;
+var safeColor = (value, fallback) => CSS_COLOR.test(value.trim()) ? value.trim() : fallback;
+var presetOrColor = (value) => isAccentPreset(value) ? ACCENTS[value] : safeColor(value, FALLBACK_ACCENT);
+var safeColorOrNull = (value) => value && CSS_COLOR.test(value.trim()) ? value.trim() : null;
+var RADII = {
+  lg: "0.75rem",
+  md: "0.5rem",
+  none: "0",
+  sm: "0.25rem"
+};
+var cssString = (value) => JSON.stringify(value);
+var backgroundImageCss = (image) => `url(${cssString(image)})`;
+var cssToken = (name, value) => value ? [`  ${name}: ${value};`] : [];
+var themeRootCss = (theme, options) => [
+  `  --blume-accent: ${options.accent};`,
+  ...cssToken("--blume-action", options.action),
+  ...cssToken("--blume-action-foreground", options.action ? "oklch(1 0 0)" : null),
+  ...cssToken("--blume-background", safeColorOrNull(theme.background?.light)),
+  ...cssToken("--blume-background-image", theme.backgroundImage?.light ? backgroundImageCss(theme.backgroundImage.light) : null),
+  `  --blume-radius: ${options.radius};`
+].filter(Boolean).join(`
+`);
+var themeDarkCss = (theme, options) => {
+  const tokens = [
+    `  --blume-accent: ${options.accent};`,
+    "  --blume-accent-foreground: oklch(1 0 0);",
+    ...cssToken("--blume-action", options.action),
+    ...cssToken("--blume-action-foreground", options.action ? "oklch(1 0 0)" : null),
+    ...cssToken("--blume-background", safeColorOrNull(theme.background?.dark)),
+    ...cssToken("--blume-background-image", theme.backgroundImage?.dark ? backgroundImageCss(theme.backgroundImage.dark) : null)
+  ].filter(Boolean);
+  return `:root[data-theme="dark"] {
+${tokens.join(`
+`)}
+}
+`;
+};
+var resolveAccent = (theme) => ({
+  dark: presetOrColor(theme.accent.dark),
+  light: presetOrColor(theme.accent.light)
+});
+var resolveRadius = (theme) => RADII[theme.radius];
+var buildThemeCss = (theme) => {
+  const accent = resolveAccent(theme);
+  const action = theme.action ? presetOrColor(theme.action) : null;
+  const radius = RADII[theme.radius];
+  const root = themeRootCss(theme, {
+    accent: accent.light,
+    action,
+    radius
+  });
+  const dark = themeDarkCss(theme, {
+    accent: accent.dark,
+    action
+  });
+  return `/* Generated by Blume from theme config. */
+:root {
+${root}
+}
+${dark}`;
+};
+
+// src/openapi/scalar.ts
+var URL_SPEC = /^https?:\/\//u;
+var referencePagePath = (route) => {
+  const segments = trimChar(route, "/");
+  return `${segments === "" ? "index" : segments}.astro`;
+};
+var themeConfiguration = (config, override) => {
+  if (override) {
+    return { theme: override };
+  }
+  const accent = resolveAccent(config.theme);
+  const radius = resolveRadius(config.theme);
+  return {
+    customCss: `:root,.light-mode,.dark-mode{--scalar-color-accent:${accent.light};--scalar-radius:${radius};}.dark-mode{--scalar-color-accent:${accent.dark};}`
+  };
+};
+var specConfiguration = async (spec, root) => {
+  if (URL_SPEC.test(spec)) {
+    return { config: { url: spec } };
+  }
+  const absolute = isAbsolute3(spec) ? spec : join8(root, spec);
+  try {
+    return { config: { content: await readFile2(absolute, "utf-8") } };
+  } catch {
+    return {
+      config: { url: spec },
+      warning: `API reference spec not found: "${spec}" (looked in ${absolute}).`
+    };
+  }
+};
+var acceptScalarReference = (ref2, seen, contentRoutes, warnings) => {
+  if (ref2.renderer !== "scalar") {
+    return null;
+  }
+  if (seen.has(ref2.route)) {
+    warnings.push(`Two API reference sources resolve to ${ref2.route}; keeping the first.`);
+    return null;
+  }
+  if (contentRoutes.has(ref2.route)) {
+    warnings.push(`API reference route ${ref2.route} collides with a content page; skipping the reference there.`);
+    return null;
+  }
+  seen.add(ref2.route);
+  return ref2;
+};
+var buildReferenceFiles = async (options) => {
+  const { config, root, contentRoutes } = options;
+  const warnings = [];
+  const seen = new Set;
+  const accepted = [];
+  for (const ref2 of resolveReferences(config)) {
+    const next = acceptScalarReference(ref2, seen, contentRoutes, warnings);
+    if (next) {
+      accepted.push(next);
+    }
+  }
+  const built = await Promise.all(accepted.map(async (ref2) => ({
+    ref: ref2,
+    spec: await specConfiguration(ref2.spec, root)
+  })));
+  const files = [];
+  for (const { ref: ref2, spec } of built) {
+    if (spec.warning) {
+      warnings.push(spec.warning);
+    }
+    const pagePath = referencePagePath(ref2.route);
+    files.push({
+      content: scalarReferenceTemplate({
+        configuration: {
+          ...spec.config,
+          ...themeConfiguration(config, ref2.theme),
+          ...ref2.scalar
+        },
+        noindex: ref2.noindex,
+        route: ref2.route,
+        title: ref2.label
+      }),
+      pagePath
+    });
+  }
+  return { files, warnings };
+};
+
+// src/search/popular.ts
+var resolveSearchPopular = (popular, basePath) => popular.map(({ href, icon, label }) => {
+  const page = {
+    label,
+    route: withBasePath(basePath, href)
+  };
+  if (icon) {
+    page.icon = icon;
+  }
+  return page;
+});
+
+// src/theme/code-block-padding.ts
+var CODE_PADDING_BLOCK_REM = 1;
+
+// src/theme/entry.ts
+var CODE_SCROLL_INSET_REM = 0.375;
+var DARK_VARIANT = `/* Dark mode is driven by data-theme on the <html> element. */
+@custom-variant dark (&:where([data-theme="dark"], [data-theme="dark"] *));`;
+var COLOR_SCHEME_DEFAULTS = `:root {
+  color-scheme: light;
+}
+
+:root[data-theme="dark"] {
+  color-scheme: dark;
+}`;
+var TOKEN_DEFAULTS = `:root {
+  --blume-background: oklch(1 0 0);
+  --blume-background-image: none;
+  --blume-background-image-repeat: no-repeat;
+  --blume-background-image-size: cover;
+  --blume-foreground: oklch(0.145 0 0);
+  --blume-muted: oklch(0.965 0 0);
+  /* 5.28:1 on the page background. The headroom over 4.5:1 is the point: muted
+     text is 14px body copy routinely set on a tinted surface (callouts, badges,
+     panels), and each tint costs a few tenths. */
+  --blume-muted-foreground: oklch(0.53 0 0);
+  --blume-border: oklch(0.88 0.006 260 / 0.72);
+  --blume-accent: oklch(0.145 0 0);
+  --blume-accent-foreground: oklch(1 0 0);
+  --blume-action: var(--blume-accent);
+  --blume-action-foreground: var(--blume-accent-foreground);
+  --blume-code-background: oklch(0.99 0 0);
+  /* Shiki notation transformers: line/word highlight, diff add/remove. */
+  --blume-code-highlight: oklch(0.55 0.16 255 / 0.1);
+  --blume-code-highlight-border: oklch(0.55 0.16 255 / 0.55);
+  --blume-code-add: oklch(0.72 0.16 150 / 0.16);
+  --blume-code-add-border: oklch(0.52 0.15 150 / 0.7);
+  --blume-code-remove: oklch(0.66 0.21 22 / 0.16);
+  --blume-code-remove-border: oklch(0.55 0.2 22 / 0.7);
+  --blume-code-word: oklch(0.55 0.16 255 / 0.16);
+  --blume-code-word-border: oklch(0.55 0.16 255 / 0.5);
+  --blume-radius: 0.75rem;
+
+  /* Max width of the prose content column (article, breadcrumb, TOC, feedback,
+     pagination, last-updated). Override to re-measure the whole column at once. */
+  --blume-content-width: 42rem;
+
+  /*
+   * Font tokens resolve through optional src variables that Astro's Fonts API
+   * populates (via theme.fonts). When unset they fall back to the system
+   * stacks, so the default look is unchanged. The display font defaults to the
+   * body font.
+   */
+  --blume-font-body: var(
+    --blume-font-body-src,
+    ui-sans-serif,
+    system-ui,
+    -apple-system,
+    "Segoe UI",
+    Roboto,
+    Helvetica,
+    Arial,
+    sans-serif
+  );
+  --blume-font-mono: var(
+    --blume-font-mono-src,
+    ui-monospace,
+    "SF Mono",
+    "Cascadia Code",
+    "Source Code Pro",
+    Menlo,
+    Consolas,
+    monospace
+  );
+  --blume-font-display: var(--blume-font-display-src, var(--blume-font-body));
+}
+
+:root[data-theme="dark"] {
+  --blume-background: oklch(0.085 0 0);
+  --blume-background-image: none;
+  --blume-background-image-repeat: no-repeat;
+  --blume-background-image-size: cover;
+  --blume-foreground: oklch(0.96 0 0);
+  --blume-muted: oklch(0.16 0 0);
+  --blume-muted-foreground: oklch(0.68 0 0);
+  --blume-border: oklch(0.24 0 0 / 0.8);
+  --blume-accent: oklch(0.96 0 0);
+  --blume-accent-foreground: oklch(0.085 0 0);
+  --blume-action: var(--blume-accent);
+  --blume-action-foreground: var(--blume-accent-foreground);
+  --blume-code-background: oklch(0.12 0 0);
+  /* Brighter tints read better over the dark code surface. */
+  --blume-code-highlight: oklch(0.7 0.14 255 / 0.16);
+  --blume-code-highlight-border: oklch(0.7 0.14 255 / 0.6);
+  --blume-code-add: oklch(0.78 0.17 150 / 0.2);
+  --blume-code-add-border: oklch(0.72 0.16 150 / 0.7);
+  --blume-code-remove: oklch(0.72 0.21 22 / 0.22);
+  --blume-code-remove-border: oklch(0.7 0.2 22 / 0.7);
+  --blume-code-word: oklch(0.7 0.14 255 / 0.22);
+  --blume-code-word-border: oklch(0.7 0.14 255 / 0.55);
+}`;
+var THEME_MAPPING = `@theme inline {
+  --color-background: var(--blume-background);
+  --color-foreground: var(--blume-foreground);
+  --color-muted: var(--blume-muted);
+  --color-muted-foreground: var(--blume-muted-foreground);
+  --color-border: var(--blume-border);
+  --color-accent: var(--blume-accent);
+  --color-accent-foreground: var(--blume-accent-foreground);
+  --color-action: var(--blume-action);
+  --color-action-foreground: var(--blume-action-foreground);
+  --color-code: var(--blume-code-background);
+  --radius-blume: var(--blume-radius);
+  --container-content: var(--blume-content-width);
+  --font-sans: var(--blume-font-body);
+  --font-mono: var(--blume-font-mono);
+  --font-display: var(--blume-font-display);
+}`;
+var tailwindEntryTemplate = (options) => `/* Generated by Blume. Do not edit. */
+@import "tailwindcss";
+@plugin "@tailwindcss/typography";
+
+/* Scan Blume's components and the user's project for utility classes. */
+${options.sources.map((source) => `@source "${source}";`).join(`
+`)}
+
+${DARK_VARIANT}
+
+${COLOR_SCHEME_DEFAULTS}
+
+${TOKEN_DEFAULTS}
+
+${THEME_MAPPING}
+
+@layer base {
+  /* Nothing refuses to shrink below its intrinsic content width. This global
+     min-width reset defuses the classic flex/grid overflow — a long or
+     truncating child forcing its container (and the page) past the viewport
+     edge — so components don't need per-element min-w-0 overrides. */
+  * {
+    min-width: 0;
+  }
+  /* Interactive controls get a pointer cursor unless disabled. */
+  button:not(:disabled),
+  [role="button"]:not(:disabled) {
+    cursor: pointer;
+  }
+  html {
+    scroll-behavior: smooth;
+    scroll-padding-top: 4.5rem;
+    text-rendering: optimizeLegibility;
+  }
+  /* Headings use the display font (defaults to the body font when unset).
+     The tightened tracking is part of the theme, not the font: display-tuned
+     families bake it into their metrics, but a text family promoted to
+     headings (including the Inter default) reads loose without it. -0.05em
+     was matched visually against Inter Tight, the previous display default. */
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6 {
+    font-family: var(--font-display);
+    letter-spacing: -0.05em;
+  }
+  :focus-visible {
+    outline: 2px solid var(--blume-accent);
+    outline-offset: 2px;
+    border-radius: 2px;
+  }
+  body {
+    background-attachment: fixed;
+    background-image: var(--blume-background-image);
+    background-position: center top;
+    background-repeat: var(--blume-background-image-repeat);
+    background-size: var(--blume-background-image-size);
+  }
+  @media (prefers-reduced-motion: reduce) {
+    html {
+      scroll-behavior: auto;
+    }
+  }
+}
+
+/* Same-origin navigations ride Astro's client router (the layouts render
+   ClientRouter), which owns the page-transition styling — including its own
+   prefers-reduced-motion guard — so the theme declares nothing about it. The
+   cross-document view-transition opt-in that briefly lived here is
+   deliberately gone: mixing it with the client router double-animates the
+   full-load navigations the router hands back to the browser. */
+
+/* Code reads left-to-right regardless of page direction; only the surrounding
+   chrome mirrors for RTL. Inline code is isolated so LTR identifiers don't
+   disturb the bidi flow of right-to-left prose. */
+[dir="rtl"] pre,
+[dir="rtl"] .prose pre {
+  direction: ltr;
+  text-align: left;
+}
+[dir="rtl"] :not(pre) > code {
+  unicode-bidi: isolate;
+}
+
+/* The sidebar's rows. A docs site renders every sidebar row on every page,
+   so a large site's HTML is mostly this markup — one utility per row kind
+   instead of the dozen classes each expands to keeps every page (and the
+   build's HTML output) small. Kept in sync with NavTree.astro: a page row,
+   a page-mode group's drill-in button, a collapsible group's summary and
+   the link inside it, and a flat group's heading and the link inside it. */
+@utility blume-nav-link {
+  @apply block rounded-[0.65rem] px-2.5 py-1.5 text-muted-foreground text-sm transition-colors hover:bg-muted hover:text-foreground aria-[current=page]:bg-muted aria-[current=page]:font-medium aria-[current=page]:text-foreground;
+}
+@utility blume-nav-drill {
+  @apply flex w-full items-center gap-2 rounded-[0.65rem] px-2.5 py-1.5 text-left font-medium text-foreground text-sm transition-colors hover:bg-muted;
+}
+@utility blume-nav-summary {
+  @apply flex cursor-pointer list-none items-center gap-1.5 rounded-[0.65rem] px-2.5 py-1.5 text-muted-foreground text-sm transition-colors hover:bg-muted hover:text-foreground [&::-webkit-details-marker]:hidden;
+}
+@utility blume-nav-summary-link {
+  @apply -my-1 flex flex-1 items-center gap-1.5 rounded py-1 transition-colors aria-[current=page]:text-foreground aria-[current=page]:font-semibold;
+}
+@utility blume-nav-heading {
+  @apply mb-2 flex items-center gap-1.5 px-2.5 font-medium text-foreground text-sm;
+}
+@utility blume-nav-heading-link {
+  @apply -ml-1 flex flex-1 items-center gap-1.5 rounded-[0.65rem] px-1 py-0.5 text-foreground transition-colors hover:bg-muted aria-[current=page]:bg-muted;
+}
+
+/* Theme Tailwind Typography (prose) with Blume tokens. */
+.prose {
+  --tw-prose-body: var(--blume-foreground);
+  --tw-prose-headings: var(--blume-foreground);
+  --tw-prose-lead: var(--blume-muted-foreground);
+  --tw-prose-links: var(--blume-foreground);
+  --tw-prose-bold: var(--blume-foreground);
+  --tw-prose-counters: var(--blume-muted-foreground);
+  --tw-prose-bullets: var(--blume-muted-foreground);
+  --tw-prose-hr: var(--blume-border);
+  --tw-prose-quotes: var(--blume-muted-foreground);
+  --tw-prose-quote-borders: var(--blume-border);
+  --tw-prose-captions: var(--blume-muted-foreground);
+  --tw-prose-code: var(--blume-foreground);
+  --tw-prose-pre-code: var(--blume-foreground);
+  --tw-prose-pre-bg: var(--blume-code-background);
+  --tw-prose-th-borders: var(--blume-border);
+  --tw-prose-td-borders: var(--blume-border);
+  color: var(--blume-muted-foreground);
+  font-size: 0.875rem;
+  line-height: 1.7;
+  /* An unbreakable run — an API permission, a broker list, a bare URL used as
+     its own link text, an OpenAPI operation title of the form
+     \`METHOD /very/long/{path}\`, a module-qualified name in a generated
+     reference — paints past the content column, and nothing between the
+     paragraph and the viewport clips it, so it lands in the document's scroll
+     width and drags the page sideways on a phone. Inherited, so headings and
+     inline code are covered too; the only re-declarations below are the
+     opt-in code-wrap mode and Twoslash, which want different values.
+     \`break-word\` and not \`anywhere\`: only \`anywhere\` reduces min-content,
+     which is what sizes \`table-layout: auto\` columns, so it would resize
+     every table on the site. The flip side is that a token in a table cell
+     still never breaks — the column grows to fit it — so wide tables rely on
+     the .blume-table-scroll wrapper, not on this. */
+  overflow-wrap: break-word;
+}
+
+/* No letter-spacing here: prose headings inherit the base h1-h6 rule's
+   display tracking, same as headings outside the prose column. */
+.prose :where(h1, h2, h3, h4) {
+  font-weight: 500;
+}
+
+.prose :where(h1) {
+  font-size: 3rem;
+  line-height: 1.1;
+  margin: 0 0 1rem;
+}
+
+.prose :where(h2) {
+  font-size: 1.875rem;
+  line-height: 1.2;
+  margin-top: 3rem;
+}
+
+.prose :where(h3) {
+  font-size: 1.25rem;
+  line-height: 1.35;
+}
+
+.prose :where(h4) {
+  color: var(--blume-muted-foreground);
+  font-size: 0.875rem;
+  line-height: 1.4;
+}
+
+.prose :where(h1, h2, h3, h4, h5, h6) a {
+  color: inherit;
+  font-weight: inherit;
+  text-decoration: none;
+}
+
+/* Auto-generated heading permalinks (markdown.headingAnchors): the whole
+   heading links to its own id, with a muted “#” revealed on hover or keyboard
+   focus so the link is discoverable without cluttering the heading at rest. */
+.prose :where(h2, h3, h4, h5, h6) a.blume-heading-anchor::after {
+  content: "#";
+  color: var(--blume-muted-foreground);
+  margin-inline-start: 0.35em;
+  opacity: 0;
+  transition: opacity 0.15s ease;
+}
+.prose :where(h2, h3, h4, h5, h6) a.blume-heading-anchor:hover::after,
+.prose :where(h2, h3, h4, h5, h6) a.blume-heading-anchor:focus-visible::after {
+  opacity: 1;
+}
+
+/* A [toc]-marked heading exists only for the table of contents: it stays in
+   the flow as a zero-height, invisible anchor target so its TOC entry (and any
+   deep link) still has somewhere to scroll to, without rendering on the page. */
+.prose :where(.blume-toc-only) {
+  border: 0;
+  height: 0;
+  margin: 0;
+  overflow: hidden;
+  padding: 0;
+  visibility: hidden;
+}
+
+.prose :where(h2:first-child) {
+  border-top: 0;
+  padding-top: 0;
+}
+
+.prose :where(p, ul, ol) {
+  margin-top: 1rem;
+  margin-bottom: 1rem;
+}
+
+.prose :where(strong) {
+  font-weight: 600;
+}
+
+.prose :where(a) {
+  color: var(--blume-foreground);
+  font-weight: 500;
+  text-decoration-line: underline;
+  text-decoration-style: dotted;
+  text-decoration-thickness: 1px;
+  text-underline-offset: 0.2em;
+}
+
+.prose :where(a[data-blume-card]) {
+  color: inherit;
+  font-weight: inherit;
+  text-decoration: none;
+}
+
+.prose :where(hr) {
+  margin: 2.5rem 0;
+}
+
+.prose :where(pre) {
+  background: transparent;
+  border: 1px solid var(--blume-border);
+  border-radius: var(--blume-radius);
+  color: var(--blume-foreground);
+  font-family: var(--font-mono);
+  font-size: 0.8125rem;
+  line-height: 1.55;
+  margin: 1.5rem 0;
+  overflow-x: auto;
+  padding: ${CODE_PADDING_BLOCK_REM}rem 0;
+  position: relative;
+}
+
+.prose :where(pre.astro-code) {
+  background: transparent !important;
+  color: var(--shiki-light, var(--blume-foreground)) !important;
+}
+
+:root[data-theme="dark"] .prose :where(pre.astro-code) {
+  color: var(--shiki-dark, var(--blume-foreground)) !important;
+}
+
+.prose :where(pre.astro-code span) {
+  background: transparent !important;
+  color: var(--shiki-light, inherit);
+  font-style: var(--shiki-light-font-style, inherit);
+  font-weight: var(--shiki-light-font-weight, inherit);
+  text-decoration: var(--shiki-light-text-decoration, inherit);
+}
+
+:root[data-theme="dark"] .prose :where(pre.astro-code span) {
+  color: var(--shiki-dark, inherit);
+  font-style: var(--shiki-dark-font-style, inherit);
+  font-weight: var(--shiki-dark-font-weight, inherit);
+  text-decoration: var(--shiki-dark-text-decoration, inherit);
+}
+
+/* The Diff component (@pierre/diffs) renders into a declarative shadow root and
+   themes itself with light-dark(). Drive that from Blume's data-theme instead
+   of the OS, scoped to the diff host: the custom property pierces the shadow
+   boundary, where the appended host color-scheme rule consumes it. */
+blume-diff {
+  --blume-diff-color-scheme: light;
+  display: block;
+}
+
+:root[data-theme="dark"] blume-diff {
+  --blume-diff-color-scheme: dark;
+}
+
+.prose :where(pre[data-language]) {
+  padding-top: 3.75rem;
+}
+
+.prose :where(pre[data-language])::before {
+  align-items: center;
+  border-bottom: 1px solid var(--blume-border);
+  color: var(--blume-muted-foreground);
+  content: attr(data-language);
+  display: flex;
+  font-family: var(--font-sans);
+  font-size: 0.75rem;
+  font-weight: 500;
+  height: 2.75rem;
+  left: 0;
+  padding: 0 3.25rem 0 1rem;
+  position: absolute;
+  right: 0;
+  top: 0;
+}
+
+.prose :where(pre[data-title])::before {
+  content: attr(data-title);
+}
+
+/* Language icon (simple-icons) sits at the header's left edge; the label shifts
+   right to make room. Injected at build time by the language-icon transformer.
+   The icon is gated on data-language (the header bar), not just data-icon: the
+   transformer runs whenever icons are on, but a header-less standalone
+   CodeBlock (no title) never gets data-language, so without this gate the
+   absolutely-positioned icon would overlap the first code line. Fenced code
+   and titled blocks always have a header, so the icon shows there. */
+.prose > :where(pre[data-language][data-icon])::after {
+  content: "";
+  height: 0.875rem;
+  left: 1rem;
+  -webkit-mask-position: center;
+  -webkit-mask-repeat: no-repeat;
+  -webkit-mask-size: contain;
+  mask-position: center;
+  mask-repeat: no-repeat;
+  mask-size: contain;
+  pointer-events: none;
+  position: absolute;
+  top: 0.875rem;
+  width: 0.875rem;
+}
+
+.prose > :where(pre[data-language][data-icon])::before {
+  padding-left: 2.5rem;
+}
+
+/* One mask rule per language the site's Markdown uses (see
+   markdown/language-icon.ts); the ::after above only gets a color and a mask
+   from these, so a block whose language has no rule paints nothing. */
+${options.languageIcons ?? ""}
+
+.prose :where(pre code) {
+  background: transparent;
+  border-radius: 0;
+  color: inherit;
+  font-size: inherit;
+  font-weight: 400;
+  padding: 0;
+}
+
+/* Long lines scroll inside the code element, not the pre: the pre stays static
+   so its absolute header bar (::before) and copy button don't drift with the
+   scroll. The pre's horizontal padding lives here so content still scrolls
+   edge-to-edge past it. Two contexts opt out: twoslash blocks (popups must
+   escape any scroll container — see theme/twoslash.ts), and the API request
+   panel, which owns its code layout and keeps the copy control in the panel
+   header. Every other component that hosts a code block — Tabs, CodeGroup,
+   Steps, Callout, Card, Accordion — is real prose content and keeps the inset,
+   even though its chrome wrapper is not-prose. */
+.prose :where(pre:not(.twoslash, .twoslash pre, blume-panel-tabs *) > code) {
+  display: block;
+  /* Tall blocks scroll vertically in place instead of taking the page. Both
+     axes live on the code element for the same reason: the pre stays static
+     so the header bar and copy button never drift with the scroll. */
+  max-height: 24rem;
+  overflow: auto;
+  /* The small bottom inset keeps the horizontal thumb off the last line's
+     descenders now that scrollbars are visible. The pre gives up the same
+     amount below (next rule), so the inset adds no height to the block. */
+  padding: 0 1.25rem ${CODE_SCROLL_INSET_REM}rem;
+  /* Thin theme-colored scrollbars, matching the sidebar treatment, so a
+     height-capped block reads as scrollable instead of simply ending.
+     Safari before 18.2 supports neither property and falls back to the
+     platform-default scrollbar — acceptable, since macOS overlays it. */
+  scrollbar-color: var(--blume-border) transparent;
+  scrollbar-width: thin;
+}
+
+/* The scroller's bottom inset comes out of the pre's own block padding: the
+   text still sits one full inset above the frame's bottom edge, the thumb sits
+   in the gap, and a one-line command is no taller than it was before the
+   scroller existed. */
+.prose :where(pre:not(.twoslash, .twoslash pre, blume-panel-tabs *):has(> code)) {
+  padding-bottom: calc(${CODE_PADDING_BLOCK_REM}rem - ${CODE_SCROLL_INSET_REM}rem);
+}
+
+/* The dark border token is too close to the page background to read as a
+   scrollbar thumb; derive a brighter one from the muted foreground instead. */
+:root[data-theme="dark"]
+  .prose
+  :where(pre:not(.twoslash, .twoslash pre, blume-panel-tabs *) > code) {
+  scrollbar-color: color-mix(in oklab, var(--blume-muted-foreground) 55%, transparent)
+    transparent;
+}
+
+/* Word wrap (markdown.code.wrap): long lines wrap instead of scrolling. The
+   attribute is set on <body> from config; default code keeps \`white-space: pre\`. */
+[data-blume-code-wrap] pre,
+[data-blume-code-wrap] pre code {
+  overflow-wrap: break-word;
+  white-space: pre-wrap;
+}
+
+.prose :where(table) {
+  font-size: 0.8125rem;
+}
+
+/* Scroll wide tables in place; the wrapper is added by the blume:table-wrap hast
+   plugin. The border+radius frames the scroll viewport so a clipped wide table
+   reads as scrollable rather than cut off, and carries the table's vertical
+   rhythm (the inner table's own margin is zeroed so it fills the frame). */
+.blume-table-scroll {
+  overflow-x: auto;
+  -webkit-overflow-scrolling: touch;
+  margin: 1.5rem 0;
+  border: 1px solid var(--blume-border);
+  border-radius: var(--blume-radius);
+}
+.blume-table-scroll > table {
+  margin: 0;
+}
+/* Restore inner padding on every cell. Typography zeroes the first/last cell's
+   inline padding so a borderless table aligns to the prose margin; inside the
+   framed wrapper that leaves edge text touching the border. The :is() selector
+   outweighs Typography's :where()-scoped rules so the outer columns get it too.
+
+   The block padding is 0.75rem against a table line-height near 1.7: at 0.5rem a
+   cell whose content wrapped put MORE space between its own two lines than
+   between itself and the next row, so a table of wrapping cells read as one
+   block rather than as rows. The inline padding stays where it was, deliberately
+   — widening it comes out of column width in a capped article, and on one corpus
+   that pushed cells fitting on two lines onto three. */
+.blume-table-scroll :is(th, td) {
+  padding: 0.75rem;
+}
+/* Keep column labels on one line so a two-word header does not wrap into a
+   ragged stack; the table just scrolls a little wider instead. Body cells keep
+   wrapping so a wide table stays a scroll away, not an endless horizontal run. */
+.blume-table-scroll th {
+  white-space: nowrap;
+}
+
+/* GFM renders cells as <td><code> directly, which the descendant form alone
+   never matches (a cell is not its own descendant). */
+.prose :where(td, th) > code,
+.prose :where(td, th) :not(pre) > code {
+  white-space: normal;
+}
+
+blume-tabs pre,
+.not-prose > div > pre {
+  background: var(--blume-code-background);
+}
+
+/* The Component source pane fills its tab's fixed height (set inline to match the
+   preview tab) and scrolls the inner code element, leaving the pre static so the
+   copy button — absolute, pinned to the pre — doesn't drift while it scrolls. */
+pre.blume-source {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  overflow: hidden;
+}
+
+pre.blume-source > code {
+  flex: 1;
+  /* The pane's measured height is authoritative (it can exceed the prose
+     24rem cap), so undo the generic prose max-height: the code must fill
+     whatever height the tab was given. */
+  max-height: none;
+  min-height: 0;
+  overflow: auto;
+}
+
+/* Code blocks inside tabs sit flush; the tab container owns the frame. These
+   rules are unlayered like the base \`pre\` styles, so they win over Tailwind's
+   layered utilities (which a class on the panel cannot). The second selector
+   covers <CodeGroup>, where each code block IS the panel (a direct child of the
+   tab content wrapper) rather than a <pre> nested inside a <Tab>. */
+blume-tabs [data-blume-tab-panel] > pre,
+blume-tabs [data-blume-tab-content] > pre {
+  /* Important to beat the astro-code background rule above; the tab container
+     owns the surface, so the code sits directly on it. */
+  background: transparent !important;
+  border: 0;
+  border-radius: 0;
+  margin: 0;
+}
+
+/* These contexts drop the language bar (\`::before\` is cleared below), so the
+   bar's padding goes with it and the block keeps the plain inset. Unscoped on
+   purpose: <CodeBlock> wraps its pre in its own \`.prose\` below the component
+   chrome, so without this a titled block on a page with no prose column
+   (PageLayout) would keep the 3.75rem bar padding under a cleared bar. */
+blume-tabs pre[data-language],
+.not-prose pre[data-language] {
+  padding-top: ${CODE_PADDING_BLOCK_REM}rem;
+}
+
+/* Where no language bar holds the copy button — a flush block in tabs or a
+   not-prose component, a bar-less block in prose — the docs layout still pins
+   one over the block's top-right corner, so a first line long enough to reach
+   it would end underneath. A code switcher (CodeGroup, ts2js) hosts the button
+   in its tab strip instead and needs nothing here; for every block that keeps
+   an overlay button, give the scrolling code element enough end padding that
+   the line's tail clears the button at the end of its scroll. Keyed on the
+   injected button itself (which the playground's client-created response pre
+   never gets), and \`.prose\`-scoped to outrank the base \`:where(pre code)\`
+   inset. Not a vertical inset — that reserved a strip above every one-line
+   command and read as a rendering bug. */
+.prose :is(blume-tabs pre, .not-prose pre, pre:not([data-language])):not(.twoslash, .twoslash pre, blume-panel-tabs *):has(> [data-blume-copy]) > code {
+  padding-inline-end: 3.5rem;
+}
+
+blume-tabs pre[data-language]::before,
+.not-prose pre[data-language]::before {
+  content: none;
+}
+
+/* Pre-hydration layout-shift guard. The horizontal trigger row and
+   single-panel visibility are built by the <blume-tabs> custom element's JS:
+   until it upgrades, the trigger row is empty and every panel is in normal flow,
+   so the browser paints all panels stacked vertically (e.g. all four
+   package-manager commands at once) before JS hides them. While the element is
+   :not(:defined), show only the first panel and reserve the trigger row's height
+   so nothing jumps when JS takes over. The child selector covers both <Tab>
+   panels and <CodeGroup> raw code blocks (which only gain
+   [data-blume-tab-panel] from JS). */
+blume-tabs:not(:defined) [data-blume-tab-content] > *:nth-child(n + 2) {
+  display: none;
+}
+
+blume-tabs:not(:defined) [data-blume-tablist] {
+  /* Matches a trigger's height: py-2.5 + text-xs line-height + border-b-2. */
+  min-height: 2.375rem;
+}
+
+blume-tabs:not(:defined)[data-dropdown="true"] [data-blume-tablist] {
+  /* Dropdown variant: p-3 padding around a select (py-2 + text-sm + border). */
+  min-height: 3.875rem;
+}
+
+/* Code blocks inside request/response example panels sit flush; the panel owns
+   the frame. Unlayered (like the tab rules) so they beat the base \`pre\` styles
+   that a class on the panel cannot. */
+[data-blume-code-panel] pre {
+  background: transparent !important;
+  border: 0;
+  border-radius: 0;
+  margin: 0;
+}
+
+/* Opt-in line numbers (\`\`\`ts file.ts lineNumbers): a counter-driven gutter that
+   works in prose and flush (tab / API panel) code blocks alike. */
+pre[data-line-numbers] code {
+  counter-reset: line;
+}
+
+pre[data-line-numbers] .line::before {
+  color: var(--blume-muted-foreground);
+  content: counter(line);
+  counter-increment: line;
+  display: inline-block;
+  margin-right: 1.25rem;
+  text-align: right;
+  user-select: none;
+  width: 1.25rem;
+}
+
+/* Shiki notation transformers (on by default). The notation comments are
+   stripped from the output; these style the classes they leave behind. A styled
+   line becomes a full-width inline-block so its background fills the row; plain
+   lines are left untouched, so blocks without notations render as before. */
+.line.highlighted,
+.line.diff {
+  display: inline-block;
+  width: 100%;
+}
+
+/* The backgrounds need !important to beat the \`pre.astro-code span\` rule above,
+   which forces token spans transparent; these line/word spans are exceptions. */
+.line.highlighted {
+  background-color: var(--blume-code-highlight) !important;
+  box-shadow: inset 2px 0 0 0 var(--blume-code-highlight-border);
+}
+
+.line.diff.add {
+  background-color: var(--blume-code-add) !important;
+  box-shadow: inset 2px 0 0 0 var(--blume-code-add-border);
+}
+
+.line.diff.remove {
+  background-color: var(--blume-code-remove) !important;
+  box-shadow: inset 2px 0 0 0 var(--blume-code-remove-border);
+}
+
+/* Word highlight (\`// [!code word:x]\`) wraps matches in an inline span. The
+   element selector keeps it ahead of the transparent token-span rule. */
+span.highlighted-word {
+  background-color: var(--blume-code-word) !important;
+  border-radius: 0.25rem;
+  box-shadow: 0 0 0 1px var(--blume-code-word-border);
+  padding: 0.1em 0.2em;
+}
+
+/* Focus (\`// [!code focus]\`): dim and blur the rest; reveal on hover. */
+pre:has(.line.focused) .line:not(.focused) {
+  filter: blur(0.085rem);
+  opacity: 0.5;
+  transition:
+    filter 0.2s ease,
+    opacity 0.2s ease;
+}
+
+pre:has(.line.focused):hover .line:not(.focused) {
+  filter: none;
+  opacity: 1;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  pre:has(.line.focused) .line:not(.focused) {
+    transition: none;
+  }
+}
+
+@media (max-width: 640px) {
+  .prose :where(h1) {
+    font-size: 2.25rem;
+  }
+
+  .prose :where(h2) {
+    font-size: 1.625rem;
+  }
+}
+
+.prose :not(pre) > code:not(:where([class~="not-prose"] *)) {
+  background: var(--blume-code-background);
+  padding: 0.15em 0.35em;
+  border-radius: 0.3rem;
+  font-family: var(--font-mono);
+  font-weight: 500;
+}
+
+.prose :not(pre) > code::before,
+.prose :not(pre) > code::after {
+  content: none;
+}
+
+/* Inline code highlighting: Shiki colors the tokens of a \`code\`{:lang} snippet
+   via the same dual-theme CSS variables as fenced blocks, keeping the inline
+   pill background. Always on — it only fires on the trailing {:lang} marker. */
+.prose code.blume-inline-code span {
+  color: var(--shiki-light);
+}
+
+:root[data-theme="dark"] .prose code.blume-inline-code span {
+  color: var(--shiki-dark);
+}
+
+/* Print / "Save as PDF" (the page-actions Export → PDF runs window.print()).
+   Strip the surrounding chrome so the printout is just the article. */
+@media print {
+  [data-blume-banner],
+  header,
+  aside,
+  [data-blume-page-actions],
+  #blume-content > nav,
+  #blume-content > details {
+    display: none !important;
+  }
+
+  /* Paper can't scroll: uncap the code scroller so long blocks print in
+     full, same as tab panels are force-expanded below. */
+  .prose :where(pre:not(.twoslash, .twoslash pre, blume-panel-tabs *) > code) {
+    max-height: none;
+    overflow: visible;
+  }
+
+  #blume-content {
+    padding: 0 !important;
+  }
+
+  .prose {
+    margin: 0 !important;
+    max-width: none !important;
+  }
+
+  /* Reveal collapsed tab panels so their content isn't dropped from the print. */
+  blume-tabs [data-blume-tab-panel] {
+    display: block !important;
+  }
+
+  /* Keep code/callout backgrounds (subject to the dialog's "Background graphics"
+     toggle). */
+  pre,
+  .prose :not(pre) > code {
+    -webkit-print-color-adjust: exact;
+    print-color-adjust: exact;
+  }
+}
+
+/* Twoslash rich-renderer styles (used by fences with the \`twoslash\` meta). */
+${options.twoslashCss ?? ""}
+
+/* Token overrides: config first, then the user's theme.css (highest priority). */
+${options.configTokens}
+${options.userTheme}
+`;
+var examplesEntryTemplate = (options) => `/* Generated by Blume. Do not edit. */
+@import "tailwindcss";
+
+/* Scan the project (and an out-of-root examples directory) for utility classes. */
+${options.sources.map((source) => `@source "${source}";`).join(`
+`)}
+
+${DARK_VARIANT}
+
+${COLOR_SCHEME_DEFAULTS}
+
+${TOKEN_DEFAULTS}
+
+${THEME_MAPPING}
+
+/* Frame defaults: readable text in both modes, transparent so the docs pane's
+   surface shows through. Base layer, so any user/example CSS wins. */
+@layer base {
+  body {
+    background: transparent;
+    color: var(--blume-foreground);
+  }
+}
+
+/* Token overrides: config first, then the configured examples css (highest
+   priority) — the place for shadcn variables and other component tokens. */
+${options.configTokens}
+${options.userCss}
+`;
+
+// src/theme/sources.ts
+import { dirname as dirname5, isAbsolute as isAbsolute4, relative as relative2, resolve as resolve5 } from "pathe";
+var SOURCE_DIRECTIVE = /@source(?<not>\s+not)?\s+(?<quote>["'])(?<path>[^"']+)\k<quote>/gu;
+var rebaseSourceDirectives = (css, options) => {
+  const base = dirname5(options.from);
+  return css.replace(SOURCE_DIRECTIVE, (directive, not, quote, path) => {
+    if (isAbsolute4(path)) {
+      return directive;
+    }
+    const rebased = relative2(options.to, resolve5(base, path));
+    return `@source${not ?? ""} ${quote}${rebased}${quote}`;
+  });
+};
+
+// src/theme/twoslash.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+var OVERRIDES = `
+/* Twoslash: theme the rich renderer with Blume tokens. */
+:root {
+  --twoslash-border-color: var(--blume-border);
+  --twoslash-popup-bg: var(--blume-code-background);
+  --twoslash-popup-color: var(--blume-foreground);
+  --twoslash-popup-shadow: 0 6px 24px oklch(0 0 0 / 0.18);
+  --twoslash-docs-color: var(--blume-muted-foreground);
+  --twoslash-docs-font: var(--font-sans);
+  --twoslash-code-font: var(--font-mono);
+  --twoslash-matched-color: var(--blume-foreground);
+  --twoslash-unmatched-color: var(--blume-muted-foreground);
+  --twoslash-cursor-color: var(--blume-muted-foreground);
+}
+
+/* Popups are absolutely positioned and must escape the pre's scroll container.
+   The base prose pre rule (from the typography layer) wins the cascade here
+   despite lower specificity, so !important is needed to force visibility.
+   Regular code blocks scroll their inner code element and carry the horizontal
+   padding there; twoslash code opts out of that scroller (popups again), so the
+   padding is restored on the pre. */
+.prose pre.twoslash {
+  overflow: visible !important;
+  padding-left: 1.25rem;
+  padding-right: 1.25rem;
+}
+
+/* Twoslash blocks keep \`overflow: visible\` so popups can escape, which means
+   long lines can't scroll — they'd push past the viewport on narrow screens.
+   Wrap them on mobile instead; hover popups still position against the token. */
+@media (max-width: 640px) {
+  .prose pre.twoslash code {
+    white-space: pre-wrap;
+    overflow-wrap: anywhere;
+  }
+}
+
+/* The rich renderer renders each popup's type signature as a nested Shiki
+   pre. Strip the code-block chrome (border, radius, padding, background) so it
+   sits flush inside the popup, which owns the frame. */
+.prose pre.twoslash .twoslash-popup-container pre {
+  background: transparent !important;
+  border: 0 !important;
+  border-radius: 0 !important;
+  margin: 0 !important;
+  padding: 0 !important;
+}
+
+/* Re-assert chrome backgrounds the transparent token-span rule would clear. */
+.twoslash .twoslash-popup-container,
+.twoslash .twoslash-popup-arrow,
+.twoslash .twoslash-completion-cursor .twoslash-completion-list {
+  background: var(--twoslash-popup-bg) !important;
+}
+.twoslash .twoslash-popup-error {
+  background: var(--twoslash-error-bg) !important;
+}
+.twoslash .twoslash-highlighted {
+  background: var(--twoslash-highlighted-bg) !important;
+}
+
+/* The error squiggle uses a background image the transparent rule clears, so
+   draw it as a wavy underline instead. */
+.twoslash .twoslash-error {
+  text-decoration: underline wavy var(--twoslash-error-color);
+  text-underline-offset: 0.25em;
+}
+
+.twoslash-popup-container {
+  max-width: min(90vw, 36rem);
+}
+`;
+var twoslashCss = () => {
+  const file = require2.resolve("@shikijs/twoslash/style-rich.css");
+  return `${readFileSync2(file, "utf-8")}
+${OVERRIDES}`;
+};
+
+// src/astro/component-slots.ts
+var EMPTY_MODULE = `// Generated by Blume. Do not edit.
+import type { ComponentOverride } from "blume/core/define-components.ts";
+export const mdxComponents: Record<string, ComponentOverride> = {};
+export const layoutOverrides: Record<string, ComponentOverride> = {};
+`;
+var attributeValue = (value) => value.replaceAll(/["\n\r]/gu, " ").trim();
+var CLIENT_LOAD = "client:load";
+var directiveFor = (override) => {
+  const framework = override.source?.framework;
+  switch (override.client) {
+    case "idle": {
+      return "client:idle";
+    }
+    case "visible": {
+      return "client:visible";
+    }
+    case "media": {
+      return override.media ? `client:media="${attributeValue(override.media)}"` : CLIENT_LOAD;
+    }
+    case "only": {
+      return framework ? `client:only="${attributeValue(framework)}"` : CLIENT_LOAD;
+    }
+    default: {
+      return CLIENT_LOAD;
+    }
+  }
+};
+var importClause = (variable, name, path) => name === "default" ? `import ${variable} from ${JSON.stringify(path)};` : `import { ${name} as ${variable} } from ${JSON.stringify(path)};`;
+var wrapperContent = (override) => {
+  const { name, path } = override.source;
+  const clause = name === "default" ? `import Component from ${JSON.stringify(path)};` : `import { ${name} as Component } from ${JSON.stringify(path)};`;
+  return `---
+// Generated by Blume. Do not edit.
+${clause}
+---
+<Component ${directiveFor(override)} {...Astro.props}><slot /></Component>
+`;
+};
+var sanitize = (value) => value.replaceAll(/[^A-Za-z0-9]/gu, (char) => `_${(char.codePointAt(0) ?? 0).toString(16)}_`);
+var planComponentSlots = (componentsFile, analysis) => {
+  const frameworks = new Set;
+  if (!componentsFile) {
+    return { frameworks, module: EMPTY_MODULE, wrappers: [] };
+  }
+  if (!analysis) {
+    return {
+      frameworks,
+      module: `// Generated by Blume. Do not edit.
+import overrides from ${JSON.stringify(componentsFile)};
+export const mdxComponents = overrides.mdx ?? {};
+export const layoutOverrides = overrides.layout ?? {};
+`,
+      wrappers: []
+    };
+  }
+  const wrappers = [];
+  const importLines = [];
+  const mdxEntries = [];
+  const layoutEntries = [];
+  let counter = 0;
+  const mdxOverrides = [...analysis.mdx, ...analysis.islands];
+  const plan = (override, group, entries) => {
+    const { source } = override;
+    if (source?.framework) {
+      frameworks.add(source.framework);
+    }
+    if (override.identifier && !override.client) {
+      return;
+    }
+    if (!source) {
+      return;
+    }
+    const variable = `__blumeSlot${counter}`;
+    counter += 1;
+    if (override.client) {
+      const name = `${group}-${sanitize(override.key)}`;
+      wrappers.push({ content: wrapperContent(override), name });
+      importLines.push(importClause(variable, "default", `./component-slots/${name}.astro`));
+    } else {
+      importLines.push(importClause(variable, source.name, source.path));
+    }
+    entries.push(`${JSON.stringify(override.key)}: ${variable}`);
+  };
+  for (const override of mdxOverrides) {
+    plan(override, "mdx", mdxEntries);
+  }
+  for (const override of analysis.layout) {
+    plan(override, "layout", layoutEntries);
+  }
+  const moduleSource = `// Generated by Blume. Do not edit.
+import overrides from ${JSON.stringify(componentsFile)};
+${importLines.join(`
+`)}${importLines.length ? `
+` : ""}export const mdxComponents = { ...(overrides.mdx ?? {})${mdxEntries.length ? `, ${mdxEntries.join(", ")}` : ""} };
+export const layoutOverrides = { ...(overrides.layout ?? {})${layoutEntries.length ? `, ${layoutEntries.join(", ")}` : ""} };
+`;
+  return { frameworks, module: moduleSource, wrappers };
+};
+
+// src/astro/examples.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import pMap2 from "p-map";
+import { isAbsolute as isAbsolute5, join as join10, relative as relative3 } from "pathe";
+import { glob as glob2 } from "tinyglobby";
+
+// src/astro/islands.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import pMap from "p-map";
+import { basename, join as join9 } from "pathe";
+import { glob } from "tinyglobby";
+var DEFAULT_CLIENT = "visible";
+var READ_CONCURRENCY = 16;
+var VALID_MODES = new Set([
+  "idle",
+  "load",
+  "only",
+  "visible"
+]);
+var isClientMode = (mode) => VALID_MODES.has(mode);
+var FRAMEWORK_BY_EXT2 = new Map([
+  ["jsx", "react"],
+  ["svelte", "svelte"],
+  ["tsx", "react"],
+  ["vue", "vue"]
+]);
+var ISLAND_FILE = /\.(?<ext>jsx|svelte|tsx|vue)$/u;
+var CLIENT_EXPORT = /export\s+const\s+client\s*(?::[^=]+)?=\s*["'](?<mode>\w+)["']/u;
+var readClientMode = (source, file, warnings) => {
+  const mode = source.match(CLIENT_EXPORT)?.groups?.mode;
+  if (!mode) {
+    return DEFAULT_CLIENT;
+  }
+  if (!isClientMode(mode)) {
+    warnings.push(`Island "${file}" declares an unknown client mode "${mode}"; defaulting to "${DEFAULT_CLIENT}". Use "load", "idle", "visible", or "only".`);
+    return DEFAULT_CLIENT;
+  }
+  return mode;
+};
+var discoverIslands = async (root) => {
+  const dir = join9(root, "islands");
+  const matches = await glob(["**/*"], {
+    absolute: true,
+    cwd: dir,
+    onlyFiles: true
+  });
+  const files = matches.toSorted();
+  const sources = await pMap(files, (file) => readFile3(file, "utf-8"), {
+    concurrency: READ_CONCURRENCY
+  });
+  const islands = [];
+  const warnings = [];
+  const seen = new Map;
+  const collectIsland = (file, source) => {
+    const base = basename(file);
+    const ext = base.match(ISLAND_FILE)?.groups?.ext;
+    const framework = ext ? FRAMEWORK_BY_EXT2.get(ext) : undefined;
+    if (!framework) {
+      return;
+    }
+    const name = base.replace(ISLAND_FILE, "");
+    if (!/^[A-Z][A-Za-z0-9_]*$/u.test(name)) {
+      warnings.push(`Island "${file}" must have a PascalCase identifier filename to be used in MDX (letters, digits, and underscores only, e.g. Counter.tsx → <Counter />); skipping it.`);
+      return;
+    }
+    const existing = seen.get(name);
+    if (existing) {
+      warnings.push(`Two islands both resolve to <${name}> ("${existing}" and "${file}"); ignoring the second. Give them distinct filenames.`);
+      return;
+    }
+    seen.set(name, file);
+    islands.push({
+      client: readClientMode(source, file, warnings),
+      file,
+      framework,
+      name
+    });
+  };
+  for (const [index, file] of files.entries()) {
+    collectIsland(file, sources[index] ?? "");
+  }
+  return { islands, warnings };
+};
+
+// src/astro/examples.ts
+var FRAMEWORK_BY_EXT3 = {
+  astro: "astro",
+  jsx: "react",
+  svelte: "svelte",
+  tsx: "react",
+  vue: "vue"
+};
+var EXAMPLE_FILE = /\.(?<ext>astro|jsx|svelte|tsx|vue)$/u;
+var DEFAULT_EXAMPLE_GLOB = "**/*.{astro,jsx,svelte,tsx,vue}";
+var READ_CONCURRENCY2 = 16;
+var EXAMPLE_SCAN_GLOB = "**/*.{astro,jsx,svelte,ts,tsx,vue}";
+var exampleScanRoots = (root, examplesDir) => {
+  const path = relative3(root, examplesDir);
+  const outside = path.startsWith("..") || isAbsolute5(path);
+  return outside ? [root, examplesDir] : [root];
+};
+var GLOB_MAGIC = /[!*?[\]{}]/u;
+var splitGlobBase = (pattern) => {
+  const segments = pattern.split("/");
+  const firstMagic = segments.findIndex((segment) => GLOB_MAGIC.test(segment));
+  return {
+    base: segments.slice(0, firstMagic).join("/"),
+    rest: segments.slice(firstMagic).join("/")
+  };
+};
+var discoverExamples = async (root, pattern = "examples") => {
+  const { base, rest } = GLOB_MAGIC.test(pattern) ? splitGlobBase(pattern) : { base: pattern, rest: DEFAULT_EXAMPLE_GLOB };
+  const dir = join10(root, base);
+  const matches = await glob2([rest], {
+    absolute: true,
+    cwd: dir,
+    onlyFiles: true
+  });
+  const files = matches.toSorted();
+  const sources = await pMap2(files, (file) => readFile4(file, "utf-8"), {
+    concurrency: READ_CONCURRENCY2
+  });
+  const examples = [];
+  const warnings = [];
+  const seen = new Map;
+  const collectExample = (file, source) => {
+    const ext = file.match(EXAMPLE_FILE)?.groups?.ext;
+    const framework = ext ? FRAMEWORK_BY_EXT3[ext] : undefined;
+    if (!(ext && framework)) {
+      return;
+    }
+    const path = relative3(dir, file).slice(0, -(ext.length + 1));
+    const existing = seen.get(path);
+    if (existing) {
+      warnings.push(`Two examples both resolve to "${path}" ("${existing}" and "${file}"); ignoring the second. Give them distinct paths.`);
+      return;
+    }
+    seen.set(path, file);
+    examples.push({
+      client: framework === "astro" ? undefined : readClientMode(source, file, warnings),
+      file,
+      framework,
+      lang: ext,
+      path,
+      source
+    });
+  };
+  for (const [index, file] of files.entries()) {
+    collectExample(file, sources[index] ?? "");
+  }
+  return { dir, examples, warnings };
+};
+var exampleMarkdownLookup = (examples) => Object.fromEntries(examples.map((example) => [
+  example.path,
+  { lang: example.lang, source: example.source }
+]));
+
+// src/astro/generate.ts
+var BLUME_SRC = join11(packageRoot(), "src");
+var canResolveFrom = (fromDir, spec) => {
+  try {
+    createRequire2(pathToFileURL(join11(fromDir, "_.js")).href).resolve(spec);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var resolveReactCompiler = (config, needsReact, pkgDir = packageRoot()) => {
+  if (!(needsReact && config.react.compiler)) {
+    return null;
+  }
+  try {
+    return createRequire2(pathToFileURL(join11(pkgDir, "_.js")).href).resolve("babel-plugin-react-compiler");
+  } catch {
+    return null;
+  }
+};
+var reactCompilerWarnings = (config, needsReact, compilerPath) => needsReact && config.react.compiler && !compilerPath ? [
+  "React Compiler is enabled but `babel-plugin-react-compiler` could not be resolved; falling back to an uncompiled build. Reinstall Blume, or set `react: { compiler: false }` to silence this."
+] : [];
+var resolveAstroPackageJson = (modulesDir) => {
+  try {
+    return realpathSync(join11(modulesDir, "astro", "package.json"));
+  } catch {
+    return null;
+  }
+};
+var resolvedAstroHit = (fromDir) => {
+  let dir = normalize(fromDir);
+  while (true) {
+    const modulesDir = join11(dir, "node_modules");
+    const pkg = resolveAstroPackageJson(modulesDir);
+    if (pkg) {
+      return { modulesDir, pkg };
+    }
+    const parent = dirname6(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+};
+var sameRealDir = (a, b) => {
+  try {
+    return realpathSync(a) === realpathSync(b);
+  } catch {
+    return false;
+  }
+};
+var depsCandidates = (pkgDir) => [
+  join11(pkgDir, "node_modules"),
+  dirname6(pkgDir)
+];
+var candidateHolding = (pkgDir, ...segments) => depsCandidates(pkgDir).find((dir) => existsSync6(join11(dir, ...segments))) ?? null;
+var symlinkDir = async (target, link) => {
+  try {
+    await symlink(target, link, "dir");
+  } catch {
+    await symlink(target, link, "junction");
+  }
+};
+var linkDepsJunction = async (link, depsDir) => {
+  let existing;
+  try {
+    existing = await lstat(link);
+  } catch {
+    existing = null;
+  }
+  if (existing) {
+    if (!existing.isSymbolicLink()) {
+      return;
+    }
+    try {
+      if (resolve6(dirname6(link), await readlink(link)) === resolve6(depsDir)) {
+        return;
+      }
+    } catch {}
+    await rm2(link, { force: true });
+  }
+  await mkdir2(dirname6(link), { recursive: true });
+  await symlinkDir(depsDir, link);
+};
+var readPkgVersion = (pkgJsonPath) => {
+  if (!pkgJsonPath) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync3(pkgJsonPath, "utf-8")).version ?? null;
+  } catch {
+    return null;
+  }
+};
+var astroConflictWarning = (blumeAstroPkg, shadowAstroPkg) => {
+  const blume = readPkgVersion(blumeAstroPkg);
+  const shadow = readPkgVersion(shadowAstroPkg);
+  const versions = blume && shadow ? `astro@${shadow} shadowing Blume's astro@${blume}` : "a second copy of Astro shadowing Blume's";
+  const pin = blume ?? "<Blume's astro version>";
+  return `Astro version conflict: another dependency hoisted ${versions} to the project root, so @astrojs/mdx binds to the wrong copy and the build fails on a missing export (e.g. "chunkToString"). A single symlink can't reconcile a split install — pin Blume's Astro by adding a package.json "overrides" (npm/bun/pnpm) or "resolutions" (yarn) entry { "astro": "${pin}" }, then reinstall. Run \`npm ls astro\` to find the dependency pulling the older copy.`;
+};
+var dropStaleDepsLink = async (link, pkgDir) => {
+  let existing;
+  try {
+    existing = await lstat(link);
+  } catch {
+    return;
+  }
+  if (!existing.isSymbolicLink()) {
+    return;
+  }
+  let linkedBlume;
+  let runningBlume;
+  try {
+    linkedBlume = await realpath(join11(link, "blume"));
+    runningBlume = await realpath(pkgDir);
+  } catch {
+    return;
+  }
+  if (linkedBlume !== runningBlume) {
+    await rm2(link, { force: true });
+  }
+};
+var ensureDepsLink = async (outDir, pkgDir = packageRoot()) => {
+  const astroDir = candidateHolding(pkgDir, "astro");
+  if (!astroDir) {
+    return null;
+  }
+  const mdxDir = candidateHolding(pkgDir, "@astrojs", "mdx");
+  const blumeAstro = resolveAstroPackageJson(astroDir);
+  await dropStaleDepsLink(join11(outDir, "node_modules"), pkgDir);
+  const outDirHit = resolvedAstroHit(outDir);
+  const astroCorrect = blumeAstro !== null && outDirHit?.pkg === blumeAstro;
+  const walkLandsInDeps = astroCorrect && outDirHit !== null && sameRealDir(outDirHit.modulesDir, astroDir);
+  if (walkLandsInDeps && mdxDir === astroDir) {
+    return null;
+  }
+  if (mdxDir && (mdxDir === astroDir || astroCorrect)) {
+    await linkDepsJunction(join11(outDir, "node_modules"), mdxDir);
+    return null;
+  }
+  return astroConflictWarning(blumeAstro, outDirHit?.pkg ?? null);
+};
+var ISLAND_FRAMEWORK_DEPS = new Map([
+  ["svelte", "@astrojs/svelte"],
+  ["vue", "@astrojs/vue"]
+]);
+var DEPLOYMENT_ADAPTER_DEPS = new Map([
+  ["cloudflare", "@astrojs/cloudflare"],
+  ["netlify", "@astrojs/netlify"]
+]);
+var islandFrameworkWarnings = (frameworks, root) => {
+  const warnings = [];
+  for (const framework of frameworks) {
+    const dep = ISLAND_FRAMEWORK_DEPS.get(framework);
+    if (dep && !canResolveFrom(root, dep)) {
+      warnings.push(`Islands use ${framework}, which needs "${dep}". Install it (e.g. \`npm install ${dep} ${framework}\`).`);
+    }
+  }
+  return warnings;
+};
+var deploymentAdapterWarnings = (deployment, root, pkgDir = packageRoot()) => {
+  const dep = deployment.output === "server" && deployment.adapter ? DEPLOYMENT_ADAPTER_DEPS.get(deployment.adapter) : undefined;
+  if (dep && !(canResolveFrom(root, dep) || canResolveFrom(pkgDir, dep))) {
+    return [
+      `Deployment adapter "${deployment.adapter}" needs "${dep}", which isn't installed. Run \`npm install ${dep}\` (or your package manager's equivalent).`
+    ];
+  }
+  return [];
+};
+var searchProviderWarnings = (provider, root, pkgDir = packageRoot()) => {
+  const warnings = [];
+  for (const dep of searchProviderMeta(provider).runtimeDeps) {
+    if (!(canResolveFrom(root, dep) || canResolveFrom(pkgDir, dep))) {
+      warnings.push(`Search provider "${provider}" needs "${dep}", which isn't installed. Run \`npm install ${dep}\` (or your package manager's equivalent).`);
+    }
+  }
+  return warnings;
+};
+var askProviderWarnings = (ask, root, pkgDir = packageRoot()) => {
+  if (!ask?.enabled || ask.endpoint) {
+    return [];
+  }
+  const dep = askBackendRuntimeDep(ask);
+  if (!dep || canResolveFrom(root, dep) || canResolveFrom(pkgDir, dep)) {
+    return [];
+  }
+  return [
+    `Ask AI provider "${ask.provider}" needs "${dep}", which isn't installed. Run \`npm install ${dep}\` (or your package manager's equivalent).`
+  ];
+};
+var examplesCssFile = (root, config) => config.examples.css ? join11(root, config.examples.css) : null;
+var writeExamplesPreview = async (options) => {
+  const { config, hasExamples, root, srcDir, write } = options;
+  if (hasExamples) {
+    await write(join11(srcDir, "pages", ...config.basePath.split("/").filter(Boolean), "blume-examples", "[...path].astro"), examplesPageTemplate());
+  }
+  const cssFile = examplesCssFile(root, config);
+  return cssFile && !existsSync6(cssFile) ? [
+    `examples.css points at "${config.examples.css}", which doesn't exist; previews render without it.`
+  ] : [];
+};
+var readOptional = async (path) => {
+  if (!path) {
+    return "";
+  }
+  try {
+    return await readFile5(path, "utf-8");
+  } catch {
+    return "";
+  }
+};
+var readUserCss = async (file, outputDir) => {
+  const css = await readOptional(file);
+  return file ? rebaseSourceDirectives(css, { from: file, to: outputDir }) : css;
+};
+var detectNeedsReact = async (root) => {
+  const matches = await glob3(["**/*.{tsx,jsx}"], {
+    cwd: root,
+    ignore: ["**/node_modules/**", "**/.blume/**", "**/dist/**"],
+    onlyFiles: true
+  });
+  return matches.length > 0;
+};
+var containsMath = (content) => content.includes("$$") || content.includes("<Math");
+var READ_CONCURRENCY3 = 16;
+var detectUsesMath = async (root, staged = []) => {
+  const files = await glob3(["**/*.{md,mdx}"], {
+    cwd: root,
+    ignore: ["**/node_modules/**", "**/.blume/**", "**/dist/**"],
+    onlyFiles: true
+  });
+  const contents = await pMap3(files, (file) => readOptional(join11(root, file)), {
+    concurrency: READ_CONCURRENCY3
+  });
+  return [...contents, ...staged].some(containsMath);
+};
+var hashConfigSource = (source) => createHash("sha256").update(source).digest("hex");
+var loadIntegrationBridge = async (config, context) => {
+  if (config.integrations.length === 0 || !context.configFile) {
+    return;
+  }
+  return {
+    configFile: relative4(context.outDir, context.configFile),
+    sourceHash: hashConfigSource(await readOptional(context.configFile))
+  };
+};
+var writeIfChanged = async (path, content) => {
+  let existing = null;
+  try {
+    existing = await readFile5(path, "utf-8");
+  } catch {
+    existing = null;
+  }
+  if (existing === content) {
+    return false;
+  }
+  await writeTextAtomic(path, content);
+  return true;
+};
+var pruneOrphans = async (srcDir, written) => {
+  const existing = await glob3("**/*", {
+    absolute: true,
+    cwd: srcDir,
+    onlyFiles: true
+  });
+  const removals = [];
+  for (const path of existing) {
+    const normalized = normalize(path);
+    if (!written.has(normalized)) {
+      removals.push(rm2(normalized, { force: true }));
+    }
+  }
+  await Promise.all(removals);
+};
+var collectStaged = (project) => {
+  const staged = new Map;
+  for (const page of project.graph.pages) {
+    if (page.collection === "staged" && page.entryId && page.body) {
+      const text = page.sourcePath ? rewriteRelativeImages({
+        deployBase: project.config.deployment.base,
+        projectRoot: project.context.root,
+        source: page.body.text,
+        sourcePath: page.sourcePath
+      }) : page.body.text;
+      staged.set(page.entryId, text);
+    }
+  }
+  return staged;
+};
+var writeStagedContent = async (out, staged) => {
+  const contentDir = stagedContentDir(out);
+  const written = new Set;
+  await Promise.all([...staged].map(async ([entryId, text]) => {
+    const path = join11(contentDir, entryId);
+    written.add(normalize(path));
+    await writeIfChanged(path, text);
+  }));
+  if (existsSync6(contentDir)) {
+    await pruneOrphans(contentDir, written);
+  }
+};
+var logoDimensions = (svg) => svg ? svgDimensions(svg) ?? undefined : undefined;
+var readLogoSvg = (project, source) => {
+  if (!source?.toLowerCase().endsWith(".svg")) {
+    return;
+  }
+  const rel = source.replace(/^\//u, "");
+  const file = [
+    join11(project.context.root, "public", rel),
+    join11(project.context.root, rel)
+  ].find((path) => existsSync6(path));
+  return file ? readFileSync3(file, "utf-8") : undefined;
+};
+var isStringShorthand = (value) => typeof value === "string";
+var headerRepoUrl = (repo, derived) => {
+  if (isStringShorthand(repo)) {
+    return repo;
+  }
+  return repo ? derived : null;
+};
+var resolveLogo = (project) => {
+  const { logo } = project.config;
+  if (!logo) {
+    return null;
+  }
+  const config = isStringShorthand(logo) ? { image: logo } : logo;
+  const { href, image: source, text } = config;
+  const image = isStringShorthand(source) ? { light: source } : source;
+  const light = image?.light ?? image?.dark;
+  const dark = image?.dark ?? image?.light;
+  const alt = image?.alt ?? "";
+  const brandHref = href ?? "/";
+  const lightSvg = readLogoSvg(project, light);
+  const darkSvg = dark === light ? lightSvg : readLogoSvg(project, dark);
+  if (light && light === dark && lightSvg) {
+    return { alt, href: brandHref, svg: lightSvg, text };
+  }
+  const lightDimensions = logoDimensions(lightSvg);
+  const darkDimensions = logoDimensions(darkSvg);
+  const dimensions = lightDimensions || darkDimensions ? { dark: darkDimensions, light: lightDimensions } : undefined;
+  return { alt, dark, dimensions, href: brandHref, light, text };
+};
+var FAVICON_CANDIDATES = [
+  "icon.svg",
+  "favicon.svg",
+  "icon.png",
+  "favicon.png",
+  "favicon.ico",
+  "icon.ico"
+];
+var darkSibling = (name) => name.replace(/\.(?=[^.]+$)/u, "-dark.");
+var FAVICON_TYPES = new Map([
+  ["ico", "image/x-icon"],
+  ["jpeg", "image/jpeg"],
+  ["jpg", "image/jpeg"],
+  ["png", "image/png"],
+  ["svg", "image/svg+xml"]
+]);
+var faviconType = (name) => {
+  const ext = name.split(".").pop()?.toLowerCase();
+  return ext ? FAVICON_TYPES.get(ext) : undefined;
+};
+var inlineDataUri = (file, type) => `data:${type};base64,${readFileSync3(file).toString("base64")}`;
+var defaultFavicon = () => ({
+  dark: {
+    href: inlineDataUri(join11(BLUME_SRC, "assets", "icon-dark.png"), "image/png"),
+    type: "image/png"
+  },
+  href: inlineDataUri(join11(BLUME_SRC, "assets", "icon.png"), "image/png"),
+  type: "image/png"
+});
+var APPLE_ICON_CANDIDATES = [
+  "apple-icon.png",
+  "apple-icon.jpg",
+  "apple-icon.jpeg",
+  "apple-touch-icon.png"
+];
+var resolveIconFile = (project, candidates) => {
+  const { root } = project.context;
+  for (const name of candidates) {
+    if (existsSync6(join11(root, "public", name))) {
+      return { href: `/${name}`, type: faviconType(name) };
+    }
+  }
+  for (const name of candidates) {
+    const file = join11(root, name);
+    if (existsSync6(file)) {
+      const type = faviconType(name);
+      return { href: inlineDataUri(file, type ?? "image/x-icon"), type };
+    }
+  }
+  return null;
+};
+var resolveFavicon = (project) => {
+  const { root } = project.context;
+  for (const name of FAVICON_CANDIDATES) {
+    if (existsSync6(join11(root, "public", name))) {
+      const type = faviconType(name);
+      const sibling = darkSibling(name);
+      return existsSync6(join11(root, "public", sibling)) ? { dark: { href: `/${sibling}`, type }, href: `/${name}`, type } : { href: `/${name}`, type };
+    }
+  }
+  for (const name of FAVICON_CANDIDATES) {
+    const file = join11(root, name);
+    if (existsSync6(file)) {
+      const type = faviconType(name);
+      const mime = type ?? "image/x-icon";
+      const siblingFile = join11(root, darkSibling(name));
+      return existsSync6(siblingFile) ? {
+        dark: { href: inlineDataUri(siblingFile, mime), type },
+        href: inlineDataUri(file, mime),
+        type
+      } : { href: inlineDataUri(file, mime), type };
+    }
+  }
+  return resolveIconFile(project, FAVICON_CANDIDATES.map(darkSibling)) ?? defaultFavicon();
+};
+var resolveAppleIcon = (project) => resolveIconFile(project, APPLE_ICON_CANDIDATES);
+var resolveBanner = (config) => {
+  const { banner } = config;
+  if (!banner) {
+    return null;
+  }
+  if (isStringShorthand(banner)) {
+    return { content: banner, dismissible: false, key: banner };
+  }
+  return {
+    content: banner.content,
+    dismissible: banner.dismissible,
+    key: banner.id ?? banner.content,
+    link: banner.link
+  };
+};
+var resolveOgMark = (project, siteLogo) => {
+  const configured = project.config.seo.og.logo;
+  if (configured === false) {
+    return false;
+  }
+  if (configured) {
+    return resolveOgLogo(project, configured);
+  }
+  return siteLogo;
+};
+var resolveOgSite = (config) => {
+  const configured = config.seo.og.site;
+  if (configured === false) {
+    return;
+  }
+  if (configured !== undefined) {
+    return configured;
+  }
+  return config.deployment.site ? `${new URL(config.deployment.site).host}${normalizeBasePath(config.deployment.base)}` : undefined;
+};
+var resolveOgDescription = (config) => {
+  const configured = config.seo.og.description;
+  if (configured === false) {
+    return;
+  }
+  return configured ?? config.description;
+};
+var resolveGithubData = (github) => github ? {
+  api: apiUrl(github),
+  host: github.host,
+  owner: github.owner,
+  repo: github.repo
+} : null;
+var buildRuntimeData = (project) => {
+  const { config, context, graph, manifest } = project;
+  const { github } = config;
+  const repoUrl2 = github ? repoUrl(github) : null;
+  const editBase = github ? editBaseUrl(github) : null;
+  const logo = resolveLogo(project);
+  const ogLogo = resolveOgMark(project, logo?.svg);
+  const editUrlFor = (sourcePath) => {
+    if (!(editBase && sourcePath)) {
+      return null;
+    }
+    const rel = relative4(context.root, sourcePath).split("\\").join("/");
+    const editDir = trimChar(github?.dir ?? "", "/");
+    const editPath = normalize(editDir ? join11(editDir, rel) : rel);
+    if (editPath.startsWith("..") || isAbsolute6(editPath)) {
+      return null;
+    }
+    return `${editBase}/${editPath}`;
+  };
+  const { i18n } = config;
+  const markUrl = headerRepoUrl(config.navigation.repo, repoUrl2);
+  const withRepoUrl = (nav) => ({
+    ...nav,
+    repoUrl: markUrl
+  });
+  const uiByLocale = i18n ? Object.fromEntries(i18n.locales.map(({ code }) => [
+    code,
+    resolveUIStrings(code, {
+      defaultLocale: i18n.defaultLocale,
+      overrides: i18n.ui
+    })
+  ])) : {};
+  const defaultUi = i18n ? resolveUIStrings(i18n.defaultLocale, {
+    defaultLocale: i18n.defaultLocale,
+    overrides: i18n.ui
+  }) : EN_UI;
+  const navigationByLocale = i18n ? Object.fromEntries(i18n.locales.map(({ code }) => [
+    code,
+    withRepoUrl(graph.navigationByLocale[code] ?? {
+      actions: [],
+      cta: null,
+      featured: [],
+      selectors: [],
+      sidebar: [],
+      tabs: []
+    })
+  ])) : {};
+  const data = {
+    config: {
+      analytics: config.analytics ?? null,
+      appleIcon: resolveAppleIcon(project),
+      ask: config.ai.ask?.enabled ? {
+        endpoint: config.ai.ask.endpoint ?? null,
+        suggestions: config.ai.ask.suggestions
+      } : null,
+      banner: resolveBanner(config),
+      basePath: config.basePath,
+      codeThemes: config.markdown.codeBlocks.theme,
+      codeWrap: config.markdown.code.wrap,
+      dateFormat: config.dateFormat,
+      description: config.description,
+      discovery: {
+        agentReadability: config.seo.agentReadability,
+        api: config.ai.api,
+        llmsTxt: config.ai.llmsTxt.enabled,
+        sitemap: config.seo.sitemap && Boolean(config.deployment.site)
+      },
+      favicon: resolveFavicon(project),
+      feedback: config.feedback,
+      github: resolveGithubData(github),
+      i18n: i18n ? {
+        defaultLocale: i18n.defaultLocale,
+        fallbackLocale: resolveFallbackLocale(i18n),
+        hideDefaultLocalePrefix: i18n.hideDefaultLocalePrefix,
+        locales: i18n.locales.map(({ code, dir, label }) => ({
+          code,
+          dir,
+          label
+        }))
+      } : null,
+      identity: config.seo.organization || config.seo.software ? {
+        organization: config.seo.organization,
+        software: config.seo.software
+      } : null,
+      imageZoom: config.markdown.imageZoom,
+      logo,
+      mcp: config.ai.mcp.enabled ? {
+        name: config.ai.mcp.name ?? config.title,
+        route: config.ai.mcp.route
+      } : null,
+      og: {
+        description: resolveOgDescription(config),
+        enabled: config.seo.og.enabled ?? false,
+        logo: ogLogo,
+        palette: config.seo.og.palette,
+        site: resolveOgSite(config)
+      },
+      openInChat: config.ai.openInChat,
+      repoUrl: repoUrl2,
+      search: {
+        enabled: config.search.provider !== "none",
+        popular: resolveSearchPopular(config.search.popular, config.basePath),
+        provider: config.search.provider
+      },
+      site: config.deployment.site ?? null,
+      structuredData: config.seo.structuredData,
+      theme: config.theme,
+      title: config.title,
+      toc: config.toc,
+      versions: config.versions ?? null,
+      webmcp: {
+        enabled: config.ai.webmcp,
+        llms: config.ai.llmsTxt.enabled
+      },
+      x: config.seo.x
+    },
+    feeds: buildRssFeeds(project).map((feed) => ({
+      href: feed.path,
+      title: feed.title
+    })),
+    fontCssVars: configuredFonts(config.theme.fonts, fontLocaleCodes(config.i18n)),
+    navigation: withRepoUrl(graph.navigation),
+    navigationByLocale,
+    navigationByVersion: Object.fromEntries(Object.entries(graph.navigationByVersion).map(([id, byLocale]) => [
+      id,
+      Object.fromEntries(Object.entries(byLocale).map(([code, nav]) => [
+        code,
+        withRepoUrl(nav)
+      ]))
+    ])),
+    routes: manifest.routes.map((route) => ({
+      alternates: route.alternates,
+      collection: route.collection,
+      description: route.description ?? null,
+      draft: route.draft,
+      editUrl: route.editUrl ?? editUrlFor(route.sourcePath),
+      entryId: route.entryId,
+      fallback: route.fallback ?? false,
+      hidden: route.hidden,
+      id: route.id,
+      indexable: route.indexable,
+      lastModified: route.lastModified ?? null,
+      locale: route.locale,
+      path: route.path,
+      title: route.title,
+      version: route.version,
+      versionAlternates: route.versionAlternates
+    })),
+    ui: defaultUi,
+    uiByLocale
+  };
+  return `${JSON.stringify(data, null, 2)}
+`;
+};
+var planMcp = (project, srcDir, userPages) => {
+  const { config } = project;
+  const { route } = config.ai.mcp;
+  const dir = join11(srcDir, "blume-mcp");
+  const base = {
+    dir,
+    discoveryPages: [],
+    enabled: false,
+    route,
+    srcDir,
+    warnings: []
+  };
+  if (!config.ai.mcp.enabled) {
+    return base;
+  }
+  if (routeIsTaken(userPages, project.graph.pages, route)) {
+    return {
+      ...base,
+      warnings: [
+        `MCP server route "${route}" is already used by a content or custom page; the MCP server was not generated. Set a different "ai.mcp.route" in blume.config.ts.`
+      ]
+    };
+  }
+  return {
+    ...base,
+    discoveryPages: [
+      {
+        entrypoint: join11(dir, "discovery.ts"),
+        pattern: "/.well-known/mcp.json"
+      },
+      {
+        entrypoint: join11(dir, "server-card.ts"),
+        pattern: "/.well-known/mcp/server-card.json"
+      }
+    ],
+    enabled: true
+  };
+};
+var publishAgentData = async (project, plans, modules) => {
+  if (!(plans.mcp.enabled || plans.api.enabled)) {
+    return null;
+  }
+  const data = await buildMcpData(project);
+  modules.set("blume:mcp-data", JSON.stringify(data));
+  return data;
+};
+var writeMcpFiles = async (plan, write, data) => {
+  if (!(plan.enabled && data)) {
+    return;
+  }
+  const discoveryInput = {
+    base: data.base,
+    name: data.name,
+    route: plan.route,
+    site: data.site,
+    version: data.version
+  };
+  await Promise.all([
+    write(join11(plan.srcDir, "pages", mcpPageFile(plan.route)), mcpEndpointTemplate()),
+    write(join11(plan.dir, "discovery.ts"), staticJsonEndpointTemplate(buildMcpDiscovery(discoveryInput))),
+    write(join11(plan.dir, "server-card.ts"), staticJsonEndpointTemplate(buildMcpServerCard(discoveryInput)))
+  ]);
+};
+var ownsApiRest = (page) => page.pattern.startsWith("/api/[");
+var contentUnderApi = (page) => page.route === "/api" || page.route.startsWith("/api/");
+var planApi = (project, srcDir, userPages) => {
+  const { config, context } = project;
+  const server = config.deployment.output === "server";
+  return {
+    catchAll: server && !userPages.some(ownsApiRest) && !project.graph.pages.some(contentUnderApi),
+    enabled: config.ai.api,
+    server,
+    spec: !routeIsTaken(userPages, project.graph.pages, OPENAPI_PATH) && !existsSync6(join11(context.root, "public", "openapi.json")),
+    srcDir
+  };
+};
+var writeApiFiles = async (project, plan, write, data, mcp) => {
+  if (!(plan.enabled && data)) {
+    return;
+  }
+  const { config } = project;
+  const mcpRoute = mcp.enabled ? mcp.route : null;
+  const apiDir = join11(plan.srcDir, "pages", "api");
+  const writes = [
+    write(join11(apiDir, "docs", "pages.json.ts"), apiPagesIndexTemplate()),
+    write(join11(apiDir, "docs", "pages", "[...route].json.ts"), apiPageTemplate()),
+    write(join11(apiDir, "docs", "navigation.json.ts"), apiNavigationTemplate())
+  ];
+  if (plan.server) {
+    writes.push(write(join11(apiDir, "docs", "search.ts"), apiSearchTemplate()));
+  }
+  if (plan.catchAll) {
+    writes.push(write(join11(apiDir, "[...path].ts"), apiNotFoundTemplate({ base: data.base, site: data.site })));
+  }
+  if (plan.spec) {
+    writes.push(write(join11(plan.srcDir, "pages", "openapi.json.ts"), staticJsonEndpointTemplate(buildApiSpec({
+      agentReadability: config.seo.agentReadability,
+      base: data.base,
+      description: config.description,
+      llmsTxt: config.ai.llmsTxt.enabled,
+      mcpRoute,
+      name: config.title,
+      search: plan.server,
+      site: data.site,
+      version: data.version
+    }))));
+  }
+  await Promise.all(writes);
+};
+var planPlaygroundProxy = (config, srcDir) => ({
+  enabled: needsPlaygroundProxy(config),
+  entrypoint: join11(srcDir, "blume-openapi", "api-proxy.ts"),
+  pattern: "/_api-proxy"
+});
+var specOriginsOf = (spec) => {
+  const origins = new Set;
+  if (spec.endpoint !== undefined) {
+    try {
+      origins.add(new URL(spec.endpoint).origin);
+    } catch {}
+  }
+  const { servers } = spec.document;
+  for (const server of Array.isArray(servers) ? servers : []) {
+    const url = server.url ?? "";
+    if (url.includes("{")) {
+      continue;
+    }
+    try {
+      origins.add(new URL(url).origin);
+    } catch {}
+  }
+  return [...origins];
+};
+var specOrigins = (data) => [...new Set(Object.values(data).flatMap(specOriginsOf))].toSorted();
+var proxyAllowlistWarnings = (config, data) => {
+  const kinds = builtinProxyKinds(config);
+  const warnings = [];
+  for (const spec of Object.values(data)) {
+    if (!kinds.includes(spec.kind) || specOriginsOf(spec).length > 0) {
+      continue;
+    }
+    warnings.push(spec.kind === "graphql" ? `The "${spec.label}" GraphQL reference (${spec.route}) has playground.proxy: true, but no absolute endpoint is configured for it, so the built-in proxy has no origin to allow and will refuse every request its playground sends. Set the graphql block's (or the source's) \`endpoint\` to the live GraphQL URL, or point playground.proxy at an external proxy URL.` : `The "${spec.label}" reference (${spec.route}) has playground.proxy: true, but its spec declares no absolute servers[].url (relative and templated URLs carry no origin), so the built-in proxy has no origin to allow and will refuse every request its playground sends. Add an absolute server URL to the spec, or point playground.proxy at an external proxy URL.`);
+  }
+  return warnings;
+};
+var writeAskFiles = async (project, srcDir, write, modules) => {
+  const { ask } = project.config.ai;
+  if (!(ask?.enabled && !ask.endpoint)) {
+    return;
+  }
+  const grounded = ask.provider !== "inkeep";
+  if (grounded) {
+    modules.set("blume:ask-data", JSON.stringify(await buildAskData(project)));
+  }
+  await write(join11(srcDir, "pages", "api", "ask.ts"), askEndpointTemplate(resolveAskBackend(ask), grounded, {
+    instructions: ask.instructions,
+    retrieval: ask.retrieval
+  }));
+};
+var writeNotFoundPage = async (write, srcDir, pages, contentPages) => {
+  if (routeIsTaken(pages, contentPages, "/404")) {
+    return;
+  }
+  await Promise.all([
+    write(join11(srcDir, "pages", "404.astro"), notFoundPageTemplate()),
+    write(join11(srcDir, "pages", "404.md.ts"), notFoundMarkdownTemplate()),
+    write(join11(srcDir, "pages", "404.json.ts"), notFoundJsonTemplate())
+  ]);
+};
+var diagnosticWarning = (diagnostic) => diagnostic.suggestion ? `${diagnostic.message} ${diagnostic.suggestion}` : diagnostic.message;
+var buildComponentSlots = async (componentsFile) => {
+  const analysis = componentsFile ? analyzeComponentOverrides(await readFile5(componentsFile, "utf-8"), componentsFile) : null;
+  return {
+    plan: planComponentSlots(componentsFile, analysis),
+    tags: analysis ? [...analysis.mdx, ...analysis.islands].map((entry) => entry.key) : [],
+    warnings: analysis ? analysis.warnings : []
+  };
+};
+var projectOgFonts = (project) => resolveOgFonts({
+  ogFonts: project.config.seo.og.fonts,
+  themeFonts: project.config.theme.fonts,
+  themeFontsConfigured: project.themeFontsConfigured
+}, project.context.root);
+var assertFontFilesExist = (project) => {
+  const { config, context } = project;
+  const missing = missingFontFiles({ ogFonts: config.seo.og.fonts ?? [], themeFonts: config.theme.fonts }, context.root);
+  if (missing.length > 0) {
+    throw new BlumeError({
+      code: "BLUME_FONT_FILE_MISSING",
+      message: `Configured font file(s) not found: ${missing.join(", ")}. Font paths resolve relative to the project root.`,
+      severity: "error"
+    });
+  }
+};
+var clientFeaturesFrom = (project, rawMarkdown) => ({
+  epub: project.config.export.epub,
+  mermaid: Object.values(rawMarkdown).some((entry) => hasMermaidFence(entry.mdx ?? entry.md ?? "")) || project.graph.pages.some((page) => page.body !== undefined && hasMermaidFence(page.body.text))
+});
+var languageIconCssFrom = (project, rawMarkdown) => languageIconCss(languageIconSlugsIn([
+  ...Object.values(rawMarkdown).map((entry) => entry.mdx ?? entry.md ?? ""),
+  ...project.graph.pages.map((page) => page.body?.text ?? "")
+].join(`
+`)));
+var languageIconCssFor = async (project) => languageIconCssFrom(project, await buildRawMarkdown(project));
+var writeNavFragments = (write, srcDir, navFragments) => navFragments ? write(join11(srcDir, "pages", "blume-nav", "[version]", "[locale]", "[id].astro"), navFragmentTemplate()) : Promise.resolve(false);
+var clientFeaturesFor = async (project) => clientFeaturesFrom(project, await buildRawMarkdown(project));
+var generateRuntime = async (project) => {
+  const { context, config } = project;
+  assertFontFilesExist(project);
+  const out = context.outDir;
+  const srcDir = join11(out, "src");
+  const generatedDir = join11(srcDir, "generated");
+  const askPath = join11(srcDir, "generated", "Ask.astro");
+  const themePath = join11(srcDir, "generated", "app.css");
+  const searchClientPath = join11(srcDir, "generated", "search-client.ts");
+  const featuresPath = join11(srcDir, "generated", "features.ts");
+  const examplesPath = join11(srcDir, "generated", "examples.ts");
+  const examplesThemePath = join11(srcDir, "generated", "examples.css");
+  const written = new Set;
+  const write = (path, content) => {
+    written.add(normalize(path));
+    return writeIfChanged(path, content);
+  };
+  const modules = new Map;
+  const depsLinkWarning = await ensureDepsLink(out);
+  const contentRoutes = markdownRoutePaths(project);
+  const homeLinkHeader = buildHomeLinkHeader(config, contentRoutes) ?? undefined;
+  const askEnabled = config.ai.ask?.enabled ?? false;
+  const exportPdf = config.export.pdf;
+  const exportEpub = config.export.epub;
+  const rawMarkdown = await buildRawMarkdown(project);
+  const clientFeatures = clientFeaturesFrom(project, rawMarkdown);
+  const navFragments = navVariants(project.graph).some(({ navigation }) => hasDeferrableGroups(navigation.sidebar));
+  const languageIcons = languageIconCssFrom(project, rawMarkdown);
+  const staged = collectStaged(project);
+  const [
+    pages,
+    detectedReact,
+    usesMath,
+    userTheme,
+    userExamplesCss,
+    integrationBridge,
+    islandDiscovery,
+    exampleDiscovery,
+    componentSlots
+  ] = await Promise.all([
+    context.pagesRoot ? discoverPages(context.pagesRoot) : Promise.resolve([]),
+    detectNeedsReact(context.root),
+    detectUsesMath(context.root, staged.values()),
+    readUserCss(context.themeFile, generatedDir),
+    readUserCss(examplesCssFile(context.root, config), generatedDir),
+    loadIntegrationBridge(config, context),
+    discoverIslands(context.root),
+    discoverExamples(context.root, config.examples.source),
+    buildComponentSlots(context.componentsFile)
+  ]);
+  const {
+    plan: slotPlan,
+    tags: overrideTags,
+    warnings: overrideWarnings
+  } = componentSlots;
+  project.examples = exampleMarkdownLookup(exampleDiscovery.examples);
+  const frameworks = new Set([
+    ...islandDiscovery.islands.map((island) => island.framework),
+    ...exampleDiscovery.examples.map((example) => example.framework),
+    ...slotPlan.frameworks
+  ]);
+  const needsReact = detectedReact || askEnabled || frameworks.has("react");
+  const needsVue = frameworks.has("vue");
+  const needsSvelte = frameworks.has("svelte");
+  const reactCompilerPath = resolveReactCompiler(config, needsReact);
+  const ogRoutes = customOgRoutes(pages, config.title, config.seo.og.titles);
+  const changelogIndex = hasGeneratedChangelog(project, pages);
+  const mcp = planMcp(project, srcDir, pages);
+  pages.push(...mcp.discoveryPages);
+  const api = planApi(project, srcDir, pages);
+  const agentData = await publishAgentData(project, { api, mcp }, modules);
+  const openApiSource = project.sources.find(isOpenApiSource);
+  const openApiData = openApiSource ? openApiSource.openApiData() : {};
+  const playgroundProxy = planPlaygroundProxy(config, srcDir);
+  if (playgroundProxy.enabled) {
+    pages.push({
+      entrypoint: playgroundProxy.entrypoint,
+      pattern: playgroundProxy.pattern
+    });
+  }
+  const proxyOrigins = specOrigins(openApiData);
+  const hasStaged = staged.size > 0;
+  const hasFilesystemSource = project.sources.some((source) => !source.staged);
+  const docsCollection = resolveDocsCollection(config, context);
+  const [structural] = await Promise.all([
+    Promise.all([
+      write(join11(out, "astro.config.mjs"), astroConfigTemplate({
+        aliases: resolveTsconfigAliases(context.root),
+        askPath,
+        config,
+        contentRoot: docsCollection.base,
+        contentRoutes,
+        context,
+        examplesPath,
+        examplesThemePath,
+        features: clientFeatures,
+        featuresPath,
+        integrationBridge,
+        needsReact,
+        needsSvelte,
+        needsVue,
+        pages,
+        reactCompilerPath,
+        searchClientPath,
+        themePath
+      })),
+      write(join11(out, "package.json"), runtimePackageTemplate(runtimeDependencies({ config, needsReact, needsSvelte, needsVue }))),
+      write(join11(out, "tsconfig.json"), runtimeTsconfigTemplate()),
+      write(join11(srcDir, "content.config.ts"), contentConfigTemplate({
+        collection: docsCollection,
+        config,
+        context,
+        filesystem: hasFilesystemSource,
+        staged: hasStaged
+      })),
+      write(join11(srcDir, "pages", "[...slug].astro"), catchAllPageTemplate({
+        exportEpub,
+        exportPdf,
+        mathEnabled: usesMath,
+        navFragments,
+        needsReact
+      })),
+      writeNavFragments(write, srcDir, navFragments),
+      write(askPath, askComponentTemplate(askEnabled)),
+      write(join11(srcDir, "generated", "components.ts"), slotPlan.module),
+      write(join11(srcDir, "generated", "islands.ts"), islandMapTemplate(islandDiscovery.islands)),
+      write(join11(srcDir, "generated", "examples.ts"), exampleMapTemplate(exampleDiscovery.examples, config.basePath)),
+      write(examplesThemePath, examplesEntryTemplate({
+        configTokens: buildThemeCss(config.theme),
+        sources: exampleScanRoots(context.root, exampleDiscovery.dir).map((dir) => `${dir}/${EXAMPLE_SCAN_GLOB}`),
+        userCss: userExamplesCss
+      })),
+      write(themePath, tailwindEntryTemplate({
+        configTokens: `${buildThemeCss(config.theme)}${buildFontsCss(config.theme.fonts)}`,
+        languageIcons,
+        sources: [
+          `${BLUME_SRC}/**/*.{astro,ts,tsx}`,
+          `${context.root}/**/*.{astro,mdx,ts,tsx}`
+        ],
+        twoslashCss: twoslashCss(),
+        userTheme
+      }))
+    ]),
+    Promise.all(islandDiscovery.islands.map((island) => write(join11(srcDir, "generated", "islands", `${island.name}.astro`), islandWrapperTemplate(island)))),
+    Promise.all(slotPlan.wrappers.map((wrapper) => write(join11(srcDir, "generated", "component-slots", `${wrapper.name}.astro`), wrapper.content))),
+    Promise.all(exampleDiscovery.examples.map((example) => write(join11(srcDir, "generated", "examples", `${exampleSlug(example.path)}.astro`), exampleWrapperTemplate(example)))),
+    writeAskFiles(project, srcDir, write, modules),
+    writeMcpFiles(mcp, write, agentData),
+    writeApiFiles(project, api, write, agentData, mcp),
+    playgroundProxy.enabled ? write(playgroundProxy.entrypoint, playgroundProxyTemplate(proxyOrigins)) : Promise.resolve(false)
+  ]);
+  if (config.seo.og.enabled) {
+    await write(join11(srcDir, "pages", "og", "[...slug].png.ts"), ogEndpointTemplate(ogRoutes, {
+      ...projectOgFonts(project),
+      cache: {
+        dir: ogCacheDir(project.context),
+        version: getBlumeVersion()
+      },
+      pageDescriptions: config.seo.og.description !== false
+    }, changelogIndex));
+  }
+  if (changelogIndex) {
+    await write(join11(srcDir, "pages", "changelog.astro"), changelogIndexTemplate({
+      exportEpub,
+      exportPdf,
+      needsReact,
+      staged: hasStaged
+    }));
+  }
+  const [examplesWarnings] = await Promise.all([
+    writeExamplesPreview({
+      config,
+      hasExamples: exampleDiscovery.examples.length > 0,
+      root: context.root,
+      srcDir,
+      write
+    }),
+    writeNotFoundPage(write, srcDir, pages, project.graph.pages),
+    write(searchClientPath, searchClientTemplate(config)),
+    write(featuresPath, featuresTemplate(clientFeatures))
+  ]);
+  if (servesStaticIndex(config.search.provider)) {
+    const documents = await buildSearchDocuments(project);
+    modules.set("blume:search-index", JSON.stringify(documents));
+    await write(join11(srcDir, "pages", "blume-search.json.ts"), searchEndpointTemplate());
+  }
+  if (config.search.provider === "mixedbread") {
+    await write(join11(srcDir, "pages", "api", "search.ts"), mixedbreadSearchEndpointTemplate(config.search.mixedbread?.storeId ?? ""));
+  }
+  await write(join11(srcDir, "generated", "includes.json"), `${JSON.stringify(buildIncludeGraph(project.graph.pages))}
+`);
+  modules.set("blume:raw-markdown", JSON.stringify(rawMarkdown));
+  const contentAssets = await collectContentAssets(project);
+  modules.set("blume:content-assets", JSON.stringify(contentAssets));
+  await Promise.all([
+    write(join11(srcDir, "pages", "[...slug].md.ts"), rawMarkdownEndpointTemplate("md")),
+    write(join11(srcDir, "pages", "[...slug].mdx.ts"), rawMarkdownEndpointTemplate("mdx")),
+    write(join11(srcDir, "pages", "blume-assets", "[...asset].ts"), contentAssetsEndpointTemplate(join11(project.context.outDir, "public", "blume-assets")))
+  ]);
+  const feeds = buildRssFeeds(project);
+  if (feeds.length > 0) {
+    const feedXml = Object.fromEntries(feeds.map((feed) => [feed.type, renderRssFeed(feed)]));
+    modules.set("blume:rss", JSON.stringify(feedXml));
+    await write(join11(srcDir, "pages", "[section]", "rss.xml.ts"), rssEndpointTemplate());
+  }
+  const warnings = [
+    ...depsLinkWarning ? [depsLinkWarning] : [],
+    ...proxyAllowlistWarnings(config, openApiData),
+    ...reactCompilerWarnings(config, needsReact, reactCompilerPath),
+    ...mcp.warnings,
+    ...islandDiscovery.warnings,
+    ...exampleDiscovery.warnings,
+    ...examplesWarnings,
+    ...overrideWarnings
+  ];
+  const navTargetRoutes = new Set([
+    ...project.graph.routes.keys(),
+    ...pages.map((page) => page.pattern),
+    ...referenceRoutes(config)
+  ]);
+  if (changelogIndex) {
+    navTargetRoutes.add("/changelog");
+  }
+  warnings.push(...[
+    ...validateNavTargets(project.graph.navigation, navTargetRoutes),
+    ...validateSearchPopularIcons(config.search.popular)
+  ].map(diagnosticWarning));
+  const knownComponentTags = new Set([
+    ...islandDiscovery.islands.map((island) => island.name),
+    ...overrideTags
+  ]);
+  warnings.push(...validateUsedComponents(project.graph.pages, knownComponentTags, new Set(registry.map((item) => item.name))).map(diagnosticWarning), ...searchProviderWarnings(config.search.provider, context.root), ...askProviderWarnings(config.ai.ask, context.root), ...deploymentAdapterWarnings(config.deployment, context.root), ...islandFrameworkWarnings(frameworks, context.root));
+  if (hasScalarReferences(config)) {
+    const references = await buildReferenceFiles({
+      config,
+      contentRoutes: new Set(project.graph.pages.map((page) => page.route)),
+      root: context.root
+    });
+    warnings.push(...references.warnings);
+    await Promise.all(references.files.map((file) => write(join11(srcDir, "pages", file.pagePath), file.content)));
+  }
+  modules.set("blume:data", buildRuntimeData(project));
+  modules.set("blume:openapi", JSON.stringify(openApiData));
+  await Promise.all([
+    write(join11(out, "blume.manifest.json"), `${JSON.stringify(project.manifest, null, 2)}
+`),
+    writeStagedContent(out, staged)
+  ]);
+  await pruneOrphans(srcDir, written);
+  publishDevNegotiation({ contentRoutes, homeLinkHeader });
+  publishRuntimeModules(modules);
+  return { structuralChange: structural.some(Boolean), warnings };
+};
+
+export { SIGNATURES_DIRECTORY_PATH, SIGNATURES_DIRECTORY_TYPE, publishBuildProject, refreshBlumeContent, showBlumeErrorOverlay, ogCacheDir, pruneCardCache, cardCacheTally, buildAskData, buildMcpDiscovery, buildMcpServerCard, buildThemeCss, buildReferenceFiles, tailwindEntryTemplate, examplesEntryTemplate, rebaseSourceDirectives, twoslashCss, planComponentSlots, discoverIslands, EXAMPLE_SCAN_GLOB, exampleScanRoots, discoverExamples, exampleMarkdownLookup, detectNeedsReact, detectUsesMath, collectStaged, buildRuntimeData, languageIconCssFor, clientFeaturesFor, generateRuntime };
+
+//# debugId=E13637FE8F0CF5E964756E2164756E21
+//# sourceMappingURL=chunk-5d4q7121.js.map