blume 1.7.3 → 2.0.1

package/dist/cli/chunk-82bbrxdn.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/deploy/adapter-output.ts"],
+  "sourcesContent": [
+    "import { existsSync } from \"node:fs\";\nimport { cp, mkdir, rm } from \"node:fs/promises\";\n\nimport { dirname, join } from \"pathe\";\n\nimport type { ResolvedConfig } from \"../core/schema.ts\";\nimport type { ProjectContext } from \"../core/types.ts\";\nimport type { ResolvedDeployment } from \"./adapters/registry.ts\";\nimport { deployPlatform } from \"./platforms/index.ts\";\nimport { distDir } from \"./platforms/paths.ts\";\n\n/**\n * Where a build's output lands. Every static build and most server builds\n * write to Astro's `outDir`; the Vercel adapter writes its Build Output tree\n * beside it instead. Each platform declares its own (see `deploy/platforms`).\n */\nexport const deployOutputDir = (\n  config: ResolvedConfig,\n  context: ProjectContext\n): string => {\n  const { deployment } = config;\n  return deployment.options.output === \"server\"\n    ? deployPlatform(deployment).serverOutputDir(context)\n    : distDir(context);\n};\n\n/**\n * Directory whose contents the deploy platform serves as static files. Build\n * artifacts (robots.txt, sitemap.xml, llms.txt, …) must be written here to be\n * served. A static build serves `dist/` wherever it lands; a server build\n * serves what its platform declares — the Build Output tree's `static/` half\n * on Vercel, Astro's `build.client` dir (`dist/client/`) on Node and\n * Cloudflare, `dist/` on Netlify.\n */\nexport const deployStaticDir = (\n  config: ResolvedConfig,\n  context: ProjectContext\n): string => {\n  const { deployment } = config;\n  return deployment.options.output === \"server\"\n    ? deployPlatform(deployment).serverStaticDir(context)\n    : distDir(context);\n};\n\n/**\n * Whether the platform applies a `_headers` file to the static assets it\n * serves — true where Netlify or Cloudflare read one, including a Cloudflare\n * **server** build (the Worker serves `dist/client` through its ASSETS\n * binding, which honors `_headers` exactly as Pages does), and for a static\n * build with no named host. Deliberately false where the file would be inert:\n * Node's standalone server has its own static handler with no `_headers`\n * support, and Vercel's headers arrive through the routing config instead.\n * Reporting a header that is not applied is worse than omitting it.\n */\nexport const readsHeaderFiles = (deployment: ResolvedDeployment): boolean =>\n  deployPlatform(deployment).readsHeaderFiles[deployment.options.output];\n\n/** Outcome of {@link surfaceAdapterOutput}, for logging. */\nexport type SurfaceResult =\n  | { moved: false }\n  | { from: string; moved: true; to: string };\n\n/**\n * Move a server adapter's deploy bundle out of the hidden `.blume` runtime and\n * up to the project root, where the deploy platform expects it. A no-op for\n * static builds, for platforms whose bundle already lands where they look\n * (`hiddenRuntime.surfacePath` is null), and when the expected output is\n * absent.\n */\nexport const surfaceAdapterOutput = async (\n  config: ResolvedConfig,\n  context: ProjectContext\n): Promise<SurfaceResult> => {\n  const { deployment } = config;\n  if (deployment.options.output !== \"server\") {\n    return { moved: false };\n  }\n  const rel = deployPlatform(deployment).hiddenRuntime.surfacePath;\n  if (!rel) {\n    return { moved: false };\n  }\n  const from = join(context.outDir, rel);\n  const to = join(context.root, rel);\n  if (!existsSync(from)) {\n    return { moved: false };\n  }\n  await mkdir(dirname(to), { recursive: true });\n  await rm(to, { force: true, recursive: true });\n  // `verbatimSymlinks` keeps each symlink's target text as written. Without it,\n  // `cp` resolves every relative target against the *source*, rewriting it to an\n  // absolute path under `.blume` — which this function then deletes. Adapters\n  // that trace dependencies into their function bundle link one package to\n  // another that way (under an isolated linker — Bun's `isolated` mode, pnpm —\n  // that is every external dependency the function imports), so the resolved\n  // links leave the deployed function dying on its first external import with\n  // ERR_MODULE_NOT_FOUND. Verbatim, the links stay relative and internal to the\n  // bundle, surviving both this move and the platform's own (Vercel mounts the\n  // bundle at `/var/task`).\n  try {\n    await cp(from, to, { recursive: true, verbatimSymlinks: true });\n  } catch (error) {\n    // SAFETY: a rejected `cp` always yields a Node system error, whose `code`\n    // is the only field read here.\n    if ((error as NodeJS.ErrnoException).code !== \"EPERM\") {\n      throw error;\n    }\n    // `EPERM` is Windows refusing to create a symlink without Developer Mode\n    // or admin rights (the same answer `symlinkDir` handles for the deps\n    // link). Copy through the links instead: each becomes an ordinary\n    // directory holding its target's files — bigger, but self-contained.\n    await rm(to, { force: true, recursive: true });\n    await cp(from, to, { dereference: true, recursive: true });\n  }\n  await rm(from, { force: true, recursive: true });\n  return { from, moved: true, to };\n};\n"
+  ],
+  "mappings": ";;;;;;;AAAA;AACA;AAEA;AAaO,IAAM,kBAAkB,CAC7B,QACA,YACW;AAAA,EACX,QAAQ,eAAe;AAAA,EACvB,OAAO,WAAW,QAAQ,WAAW,WACjC,eAAe,UAAU,EAAE,gBAAgB,OAAO,IAClD,QAAQ,OAAO;AAAA;AAWd,IAAM,kBAAkB,CAC7B,QACA,YACW;AAAA,EACX,QAAQ,eAAe;AAAA,EACvB,OAAO,WAAW,QAAQ,WAAW,WACjC,eAAe,UAAU,EAAE,gBAAgB,OAAO,IAClD,QAAQ,OAAO;AAAA;AA4Bd,IAAM,uBAAuB,OAClC,QACA,YAC2B;AAAA,EAC3B,QAAQ,eAAe;AAAA,EACvB,IAAI,WAAW,QAAQ,WAAW,UAAU;AAAA,IAC1C,OAAO,EAAE,OAAO,MAAM;AAAA,EACxB;AAAA,EACA,MAAM,MAAM,eAAe,UAAU,EAAE,cAAc;AAAA,EACrD,IAAI,CAAC,KAAK;AAAA,IACR,OAAO,EAAE,OAAO,MAAM;AAAA,EACxB;AAAA,EACA,MAAM,OAAO,KAAK,QAAQ,QAAQ,GAAG;AAAA,EACrC,MAAM,KAAK,KAAK,QAAQ,MAAM,GAAG;AAAA,EACjC,IAAI,CAAC,WAAW,IAAI,GAAG;AAAA,IACrB,OAAO,EAAE,OAAO,MAAM;AAAA,EACxB;AAAA,EACA,MAAM,MAAM,QAAQ,EAAE,GAAG,EAAE,WAAW,KAAK,CAAC;AAAA,EAC5C,MAAM,GAAG,IAAI,EAAE,OAAO,MAAM,WAAW,KAAK,CAAC;AAAA,EAW7C,IAAI;AAAA,IACF,MAAM,GAAG,MAAM,IAAI,EAAE,WAAW,MAAM,kBAAkB,KAAK,CAAC;AAAA,IAC9D,OAAO,OAAO;AAAA,IAGd,IAAK,MAAgC,SAAS,SAAS;AAAA,MACrD,MAAM;AAAA,IACR;AAAA,IAKA,MAAM,GAAG,IAAI,EAAE,OAAO,MAAM,WAAW,KAAK,CAAC;AAAA,IAC7C,MAAM,GAAG,MAAM,IAAI,EAAE,aAAa,MAAM,WAAW,KAAK,CAAC;AAAA;AAAA,EAE3D,MAAM,GAAG,MAAM,EAAE,OAAO,MAAM,WAAW,KAAK,CAAC;AAAA,EAC/C,OAAO,EAAE,MAAM,OAAO,MAAM,GAAG;AAAA;",
+  "debugId": "8B79889B6B3550F964756E2164756E21",
+  "names": []
+}

package/dist/cli/chunk-abh8yjkn.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+// src/core/sources/watch.ts
+var BLUME_IGNORE_DIRS = [
+  ".blume",
+  ".blume-verify",
+  ".cache",
+  ".git",
+  ".next",
+  ".turbo",
+  ".vercel",
+  "dist",
+  "node_modules"
+];
+var baselineScanIgnore = () => BLUME_IGNORE_DIRS.map((dir) => `**/${dir}/**`);
+var BLUME_WATCH_IGNORE_DIRS = BLUME_IGNORE_DIRS;
+var excludeDirSegments = (patterns) => patterns.map((pattern) => /^(?<dir>[^*/]+)\/\*\*$/u.exec(pattern)?.groups?.dir).filter((dir) => dir !== undefined);
+var ignoringWatchListener = (onChange, ignoreDirs = BLUME_WATCH_IGNORE_DIRS, ignoreSegment = () => false) => {
+  const ignore = new Set(ignoreDirs);
+  return (_event, filename) => {
+    if (filename !== null && filename.split(/[/\\]/u).some((segment) => ignore.has(segment) || ignoreSegment(segment))) {
+      return;
+    }
+    onChange();
+  };
+};
+
+export { BLUME_IGNORE_DIRS, baselineScanIgnore, BLUME_WATCH_IGNORE_DIRS, excludeDirSegments, ignoringWatchListener };
+
+//# debugId=E327C8C451E6563064756E2164756E21
+//# sourceMappingURL=chunk-abh8yjkn.js.map

package/dist/cli/chunk-abh8yjkn.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/core/sources/watch.ts"],
+  "sourcesContent": [
+    "import type { WatchListener } from \"node:fs\";\n\n/**\n * Directory segments that are never authored content: VCS, dependency trees,\n * Blume's own generated project and build output, and framework/deploy caches.\n * Both the content scan and the dev watcher skip these unconditionally, on top\n * of the user's `content.exclude`.\n *\n * The scan needs them because a broadly-scoped `content.root` — `\".\"` or an app\n * dir that also holds `node_modules`/`dist`, the common shape when migrating a\n * docs app that lives at the repo or app root — would otherwise glob thousands\n * of stray markdown files out of dependencies and build artifacts. `content.root`\n * defaults to `docs/` where this rarely bites, but any wider root hits it.\n *\n * The watcher needs them because a recursive `fs.watch` rooted at the project\n * also sees Blume's own `.blume/` output, which the dev server rewrites on every\n * render (e.g. `.blume/.astro/data-store.json`). Left unfiltered, each such write\n * re-triggers a rescan + runtime regeneration whose writes land back under\n * `.blume/` and fire the watcher again: a self-sustaining loop that stalls page\n * renders and floods the console. `fs.watch` has no ignore option, so we filter\n * by the changed path in the callback.\n */\nexport const BLUME_IGNORE_DIRS = [\n  \".blume\",\n  // The isolated `blume check --isolated` runtime. A sibling of `.blume`, it is\n  // written while a dev server runs; without this the content-layer watcher (or\n  // a `.`-rooted fs.watch) would treat its generation as a content change and\n  // reload — the very thing `--isolated` promises not to do.\n  \".blume-verify\",\n  \".cache\",\n  \".git\",\n  \".next\",\n  \".turbo\",\n  \".vercel\",\n  \"dist\",\n  \"node_modules\",\n];\n\n/**\n * Baseline scan-ignore globs applied to every filesystem source, unioned with\n * the user's `content.exclude`. Kept in sync with the watcher via the shared\n * {@link BLUME_IGNORE_DIRS} so `load()` and `watch()` never disagree on what is\n * content. `**\\/<dir>/**` matches the directory at the content root or nested.\n */\nexport const baselineScanIgnore = (): string[] =>\n  BLUME_IGNORE_DIRS.map((dir) => `**/${dir}/**`);\n\n/**\n * Alias retained for the dev watcher's call site and its tests; the watcher and\n * the scan share the same never-content directory set.\n */\nexport const BLUME_WATCH_IGNORE_DIRS = BLUME_IGNORE_DIRS;\n\n/** Extract single-segment ignore dirs (`foo`) from `foo/**`-style excludes. */\nexport const excludeDirSegments = (patterns: readonly string[]): string[] =>\n  patterns\n    .map((pattern) => /^(?<dir>[^*/]+)\\/\\*\\*$/u.exec(pattern)?.groups?.dir)\n    .filter((dir): dir is string => dir !== undefined);\n\n/**\n * Build a recursive-watch listener that fires `onChange` for content changes but\n * ignores events whose path crosses an ignored directory segment — one in\n * `ignoreDirs`, or one `ignoreSegment` rejects, for a scan whose skip rule is\n * a shape (every dot-name) rather than a list. A missing `filename` — rare;\n * the platform couldn't name the changed path — falls through to `onChange`\n * rather than silently dropping a real edit. Exported for testing.\n */\nexport const ignoringWatchListener = (\n  onChange: () => void,\n  ignoreDirs: Iterable<string> = BLUME_WATCH_IGNORE_DIRS,\n  ignoreSegment: (segment: string) => boolean = () => false\n): WatchListener<string> => {\n  const ignore = new Set(ignoreDirs);\n  return (_event, filename) => {\n    if (\n      filename !== null &&\n      filename\n        .split(/[/\\\\]/u)\n        .some((segment) => ignore.has(segment) || ignoreSegment(segment))\n    ) {\n      return;\n    }\n    onChange();\n  };\n};\n"
+  ],
+  "mappings": ";;;AAsBO,IAAM,oBAAoB;AAAA,EAC/B;AAAA,EAKA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAQO,IAAM,qBAAqB,MAChC,kBAAkB,IAAI,CAAC,QAAQ,MAAM,QAAQ;AAMxC,IAAM,0BAA0B;AAGhC,IAAM,qBAAqB,CAAC,aACjC,SACG,IAAI,CAAC,YAAY,0BAA0B,KAAK,OAAO,GAAG,QAAQ,GAAG,EACrE,OAAO,CAAC,QAAuB,QAAQ,SAAS;AAU9C,IAAM,wBAAwB,CACnC,UACA,aAA+B,yBAC/B,gBAA8C,MAAM,UAC1B;AAAA,EAC1B,MAAM,SAAS,IAAI,IAAI,UAAU;AAAA,EACjC,OAAO,CAAC,QAAQ,aAAa;AAAA,IAC3B,IACE,aAAa,QACb,SACG,MAAM,QAAQ,EACd,KAAK,CAAC,YAAY,OAAO,IAAI,OAAO,KAAK,cAAc,OAAO,CAAC,GAClE;AAAA,MACA;AAAA,IACF;AAAA,IACA,SAAS;AAAA;AAAA;",
+  "debugId": "E327C8C451E6563064756E2164756E21",
+  "names": []
+}

package/dist/cli/chunk-ah61y8py.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import {
+  needsPlaygroundProxy,
+  resolveAskBackend
+} from "./chunk-qkqwkpte.js";
+
+// src/core/server-features.ts
+var serverFeatures = (config) => {
+  const features = [];
+  if (config.ai.assistant?.enabled && !config.ai.assistant.endpoint) {
+    features.push("Assistant");
+  }
+  if (config.agents.mcp.enabled) {
+    features.push("MCP server");
+  }
+  if (needsPlaygroundProxy(config)) {
+    features.push("API playground proxy");
+  }
+  if (config.search.provider.mode === "server") {
+    features.push(`Search (${config.search.provider.kind})`);
+  }
+  return features;
+};
+
+// src/cli/required-secrets.ts
+var checkRequiredSecrets = (config) => {
+  const diagnostics = [];
+  const requireSecret = (feature, env, note) => {
+    if (process.env[env]) {
+      return;
+    }
+    const noteSuffix = note ? ` (${note})` : "";
+    diagnostics.push({
+      code: "BLUME_MISSING_SECRET",
+      message: `${feature} is enabled but ${env} is not set${noteSuffix}.`,
+      severity: "warning",
+      suggestion: `Set ${env} in .env.local for local dev, or in your host's environment for production.`
+    });
+  };
+  if (config.ai.assistant?.enabled && !config.ai.assistant.endpoint) {
+    const { provider } = config.ai.assistant;
+    const backend = resolveAskBackend(provider);
+    for (const env of provider.requiredSecrets) {
+      requireSecret(`Assistant (${backend.label})`, env, backend.secretNote);
+    }
+  }
+  const { provider } = config.search;
+  for (const env of provider.requiredSecrets) {
+    requireSecret(`Search (${provider.kind})`, env);
+  }
+  for (const adapter of config.analytics) {
+    for (const env of adapter.requiredSecrets) {
+      requireSecret(`Analytics (${adapter.kind})`, env);
+    }
+  }
+  for (const source of config.content.sources) {
+    for (const env of source.requiredSecrets) {
+      requireSecret(`Content source (${source.kind})`, env);
+    }
+  }
+  for (const adapter of config.reference) {
+    for (const env of adapter.requiredSecrets) {
+      requireSecret(`API reference (${adapter.kind})`, env);
+    }
+  }
+  for (const env of config.deployment.requiredSecrets) {
+    requireSecret(`Deployment (${config.deployment.kind})`, env);
+  }
+  return diagnostics;
+};
+
+export { serverFeatures, checkRequiredSecrets };
+
+//# debugId=26CFBC953FC234CC64756E2164756E21
+//# sourceMappingURL=chunk-ah61y8py.js.map

package/dist/cli/chunk-ah61y8py.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/core/server-features.ts", "../src/cli/required-secrets.ts"],
+  "sourcesContent": [
+    "import { needsPlaygroundProxy } from \"../openapi/references.ts\";\nimport type { ResolvedConfig } from \"./schema.ts\";\n\n/**\n * List the enabled features that require Astro server output. Static builds\n * fail clearly when any of these are enabled.\n */\nexport const serverFeatures = (config: ResolvedConfig): string[] => {\n  const features: string[] = [];\n  if (config.ai.assistant?.enabled && !config.ai.assistant.endpoint) {\n    features.push(\"Assistant\");\n  }\n  // The hosted MCP server is a live JSON-RPC endpoint, so it needs a runtime.\n  if (config.agents.mcp.enabled) {\n    features.push(\"MCP server\");\n  }\n  // The built-in playground proxy (`playground.proxy: true` on an `openapi()`\n  // or `graphql()` adapter) is a live fetch endpoint at `/_api-proxy`; an\n  // external proxy URL (string) or a proxy-less playground stays fully static.\n  if (needsPlaygroundProxy(config)) {\n    features.push(\"API playground proxy\");\n  }\n  // A `server` adapter (Mixedbread) proxies queries through a secret server\n  // endpoint, so it can't run on a static build.\n  if (config.search.provider.mode === \"server\") {\n    features.push(`Search (${config.search.provider.kind})`);\n  }\n  return features;\n};\n",
+    "import { resolveAskBackend } from \"../ai/ask.ts\";\nimport type { ResolvedConfig } from \"../core/schema.ts\";\nimport type { Diagnostic } from \"../core/types.ts\";\n\n/**\n * Warn early when an enabled feature needs a secret env var that isn't set, so\n * the failure surfaces at `blume dev`/`build` instead of at the first request in\n * production. These are runtime secrets (the endpoint reads them on the server),\n * so this warns rather than hard-fails — the value may live only in the deploy\n * environment. Build-time secrets (search-index sync) already warn during sync.\n */\nexport const checkRequiredSecrets = (config: ResolvedConfig): Diagnostic[] => {\n  const diagnostics: Diagnostic[] = [];\n  const requireSecret = (feature: string, env: string, note?: string): void => {\n    if (process.env[env]) {\n      return;\n    }\n    const noteSuffix = note ? ` (${note})` : \"\";\n    diagnostics.push({\n      code: \"BLUME_MISSING_SECRET\",\n      message: `${feature} is enabled but ${env} is not set${noteSuffix}.`,\n      severity: \"warning\",\n      suggestion: `Set ${env} in .env.local for local dev, or in your host's environment for production.`,\n    });\n  };\n\n  if (config.ai.assistant?.enabled && !config.ai.assistant.endpoint) {\n    // The adapter descriptor names the env vars its route reads.\n    const { provider } = config.ai.assistant;\n    const backend = resolveAskBackend(provider);\n    for (const env of provider.requiredSecrets) {\n      requireSecret(`Assistant (${backend.label})`, env, backend.secretNote);\n    }\n  }\n\n  // Each search adapter declares the secrets its generated runtime reads.\n  const { provider } = config.search;\n  for (const env of provider.requiredSecrets) {\n    requireSecret(`Search (${provider.kind})`, env);\n  }\n\n  // Adapters name their own secrets; the built-in analytics adapters ship\n  // public tokens in the page and declare none.\n  for (const adapter of config.analytics) {\n    for (const env of adapter.requiredSecrets) {\n      requireSecret(`Analytics (${adapter.kind})`, env);\n    }\n  }\n\n  // Each content source adapter declares the env vars its fetch reads.\n  for (const source of config.content.sources) {\n    for (const env of source.requiredSecrets) {\n      requireSecret(`Content source (${source.kind})`, env);\n    }\n  }\n\n  // Adapters name their own secrets; the built-in reference adapters read\n  // public specs and declare none.\n  for (const adapter of config.reference) {\n    for (const env of adapter.requiredSecrets) {\n      requireSecret(`API reference (${adapter.kind})`, env);\n    }\n  }\n\n  // The deployment adapter names its own secrets; the built-in host adapters\n  // read platform-injected env and declare none.\n  for (const env of config.deployment.requiredSecrets) {\n    requireSecret(`Deployment (${config.deployment.kind})`, env);\n  }\n\n  return diagnostics;\n};\n"
+  ],
+  "mappings": ";;;;;;;AAOO,IAAM,iBAAiB,CAAC,WAAqC;AAAA,EAClE,MAAM,WAAqB,CAAC;AAAA,EAC5B,IAAI,OAAO,GAAG,WAAW,WAAW,CAAC,OAAO,GAAG,UAAU,UAAU;AAAA,IACjE,SAAS,KAAK,WAAW;AAAA,EAC3B;AAAA,EAEA,IAAI,OAAO,OAAO,IAAI,SAAS;AAAA,IAC7B,SAAS,KAAK,YAAY;AAAA,EAC5B;AAAA,EAIA,IAAI,qBAAqB,MAAM,GAAG;AAAA,IAChC,SAAS,KAAK,sBAAsB;AAAA,EACtC;AAAA,EAGA,IAAI,OAAO,OAAO,SAAS,SAAS,UAAU;AAAA,IAC5C,SAAS,KAAK,WAAW,OAAO,OAAO,SAAS,OAAO;AAAA,EACzD;AAAA,EACA,OAAO;AAAA;;;AChBF,IAAM,uBAAuB,CAAC,WAAyC;AAAA,EAC5E,MAAM,cAA4B,CAAC;AAAA,EACnC,MAAM,gBAAgB,CAAC,SAAiB,KAAa,SAAwB;AAAA,IAC3E,IAAI,QAAQ,IAAI,MAAM;AAAA,MACpB;AAAA,IACF;AAAA,IACA,MAAM,aAAa,OAAO,KAAK,UAAU;AAAA,IACzC,YAAY,KAAK;AAAA,MACf,MAAM;AAAA,MACN,SAAS,GAAG,0BAA0B,iBAAiB;AAAA,MACvD,UAAU;AAAA,MACV,YAAY,OAAO;AAAA,IACrB,CAAC;AAAA;AAAA,EAGH,IAAI,OAAO,GAAG,WAAW,WAAW,CAAC,OAAO,GAAG,UAAU,UAAU;AAAA,IAEjE,QAAQ,aAAa,OAAO,GAAG;AAAA,IAC/B,MAAM,UAAU,kBAAkB,QAAQ;AAAA,IAC1C,WAAW,OAAO,SAAS,iBAAiB;AAAA,MAC1C,cAAc,cAAc,QAAQ,UAAU,KAAK,QAAQ,UAAU;AAAA,IACvE;AAAA,EACF;AAAA,EAGA,QAAQ,aAAa,OAAO;AAAA,EAC5B,WAAW,OAAO,SAAS,iBAAiB;AAAA,IAC1C,cAAc,WAAW,SAAS,SAAS,GAAG;AAAA,EAChD;AAAA,EAIA,WAAW,WAAW,OAAO,WAAW;AAAA,IACtC,WAAW,OAAO,QAAQ,iBAAiB;AAAA,MACzC,cAAc,cAAc,QAAQ,SAAS,GAAG;AAAA,IAClD;AAAA,EACF;AAAA,EAGA,WAAW,UAAU,OAAO,QAAQ,SAAS;AAAA,IAC3C,WAAW,OAAO,OAAO,iBAAiB;AAAA,MACxC,cAAc,mBAAmB,OAAO,SAAS,GAAG;AAAA,IACtD;AAAA,EACF;AAAA,EAIA,WAAW,WAAW,OAAO,WAAW;AAAA,IACtC,WAAW,OAAO,QAAQ,iBAAiB;AAAA,MACzC,cAAc,kBAAkB,QAAQ,SAAS,GAAG;AAAA,IACtD;AAAA,EACF;AAAA,EAIA,WAAW,OAAO,OAAO,WAAW,iBAAiB;AAAA,IACnD,cAAc,eAAe,OAAO,WAAW,SAAS,GAAG;AAAA,EAC7D;AAAA,EAEA,OAAO;AAAA;",
+  "debugId": "26CFBC953FC234CC64756E2164756E21",
+  "names": []
+}

package/dist/cli/{chunk-dwgcp5sm.js → chunk-ce574jw2.js}

@@ -20,4 +20,4 @@ var parsePort = (value) => {
 export { parsePort };
 
 //# debugId=EAEB4015F7DCE38D64756E2164756E21
-//# sourceMappingURL=chunk-dwgcp5sm.js.map
+//# sourceMappingURL=chunk-ce574jw2.js.map

package/dist/cli/chunk-ch6g3ar0.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import {
+  discoverPages,
+  customStaticRoutes,
+  hasGeneratedChangelog,
+  validateLinks
+} from "./chunk-qkqwkpte.js";
+import {
+  commandMeta,
+  reportInternalError,
+  BlumeError,
+  logger,
+  flushStdout,
+  reportDiagnosticsJson,
+  reportDiagnostics
+} from "./index.js";
+import"./chunk-jts8mvcz.js";
+import {
+  buildManifest,
+  scanProject
+} from "./chunk-fs23ddbb.js";
+
+// src/cli/commands/validate.ts
+import { existsSync } from "node:fs";
+import { defineCommand } from "citty";
+import { join } from "pathe";
+var validateCommand = defineCommand({
+  args: {
+    external: {
+      description: "Check external (HTTP) links over the network.",
+      type: "boolean"
+    },
+    json: {
+      description: "Emit diagnostics as JSON on stdout (for CI/editors).",
+      type: "boolean"
+    },
+    strict: {
+      description: "Treat warnings as errors.",
+      type: "boolean"
+    }
+  },
+  meta: commandMeta.validate,
+  async run({ args }) {
+    const root = process.cwd();
+    const diagnostics = [];
+    try {
+      const project = await scanProject(root, { mode: "build" });
+      diagnostics.push(...project.diagnostics);
+      const userPages = project.context.pagesRoot ? await discoverPages(project.context.pagesRoot) : [];
+      const extraRoutes = customStaticRoutes(userPages);
+      if (hasGeneratedChangelog(project, userPages)) {
+        extraRoutes.push("/changelog");
+      }
+      if (project.config.i18n) {
+        const manifest = buildManifest({
+          config: project.config,
+          context: project.context,
+          graph: project.graph
+        });
+        extraRoutes.push(...manifest.routes.flatMap((route) => route.fallback ? [route.path] : []));
+      }
+      const publicDir = join(root, "public");
+      diagnostics.push(...await validateLinks(project.graph, {
+        basePath: project.config.basePath,
+        checkExternal: Boolean(args.external),
+        extraRoutes,
+        i18n: project.config.i18n,
+        publicDir: existsSync(publicDir) ? publicDir : null,
+        redirects: project.config.redirects
+      }));
+    } catch (error) {
+      if (error instanceof BlumeError) {
+        diagnostics.push(error.diagnostic);
+      } else {
+        reportInternalError(error);
+        process.exit(1);
+      }
+    }
+    const strictFailure = Boolean(args.strict) && diagnostics.some((diagnostic) => diagnostic.severity !== "info");
+    if (args.json) {
+      const hadErrors = reportDiagnosticsJson(diagnostics, root);
+      if (hadErrors || strictFailure) {
+        await flushStdout();
+        process.exit(1);
+      }
+      return;
+    }
+    const hadErrors = reportDiagnostics(diagnostics, root);
+    if (diagnostics.length === 0) {
+      logger.success("No broken links found.");
+    }
+    if (hadErrors || strictFailure) {
+      process.exit(1);
+    }
+  }
+});
+export {
+  validateCommand
+};
+
+//# debugId=1EEBE4960D9C18F364756E2164756E21
+//# sourceMappingURL=chunk-ch6g3ar0.js.map

package/dist/cli/chunk-ch6g3ar0.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/cli/commands/validate.ts"],
+  "sourcesContent": [
+    "import { existsSync } from \"node:fs\";\n\nimport { defineCommand } from \"citty\";\nimport { join } from \"pathe\";\n\nimport {\n  customStaticRoutes,\n  discoverPages,\n  hasGeneratedChangelog,\n} from \"../../astro/pages.ts\";\nimport { BlumeError } from \"../../core/diagnostics.ts\";\nimport { validateLinks } from \"../../core/links.ts\";\nimport { buildManifest } from \"../../core/manifest.ts\";\nimport { scanProject } from \"../../core/project-graph.ts\";\nimport type { Diagnostic } from \"../../core/types.ts\";\nimport { commandMeta } from \"../command-meta.ts\";\nimport { reportInternalError } from \"../internal-error.ts\";\nimport {\n  flushStdout,\n  logger,\n  reportDiagnostics,\n  reportDiagnosticsJson,\n} from \"../log.ts\";\n\nexport const validateCommand = defineCommand({\n  args: {\n    external: {\n      description: \"Check external (HTTP) links over the network.\",\n      type: \"boolean\",\n    },\n    json: {\n      description: \"Emit diagnostics as JSON on stdout (for CI/editors).\",\n      type: \"boolean\",\n    },\n    strict: {\n      description: \"Treat warnings as errors.\",\n      type: \"boolean\",\n    },\n  },\n  meta: commandMeta.validate,\n  async run({ args }) {\n    const root = process.cwd();\n    const diagnostics: Diagnostic[] = [];\n\n    try {\n      const project = await scanProject(root, { mode: \"build\" });\n      // Surface content/graph problems too: a page that fails to parse is a\n      // link-validation blind spot, so silently passing would be misleading.\n      diagnostics.push(...project.diagnostics);\n\n      // Custom `.astro` pages and the generated changelog index are servable\n      // routes the content graph can't see — without them, a docs link to e.g.\n      // a custom landing page fails as BLUME_BROKEN_LINK.\n      const userPages = project.context.pagesRoot\n        ? await discoverPages(project.context.pagesRoot)\n        : [];\n      const extraRoutes = customStaticRoutes(userPages);\n      if (hasGeneratedChangelog(project, userPages)) {\n        extraRoutes.push(\"/changelog\");\n      }\n\n      // Fallback-materialized locale routes (an untranslated page prerendered\n      // at its localized URL) are servable but absent from the content graph —\n      // without them a link to an untranslated sibling under a non-default\n      // locale fails as BLUME_BROKEN_LINK even though the built site serves it.\n      if (project.config.i18n) {\n        const manifest = buildManifest({\n          config: project.config,\n          context: project.context,\n          graph: project.graph,\n        });\n        extraRoutes.push(\n          ...manifest.routes.flatMap((route) =>\n            route.fallback ? [route.path] : []\n          )\n        );\n      }\n\n      const publicDir = join(root, \"public\");\n      diagnostics.push(\n        ...(await validateLinks(project.graph, {\n          basePath: project.config.basePath,\n          checkExternal: Boolean(args.external),\n          extraRoutes,\n          i18n: project.config.i18n,\n          publicDir: existsSync(publicDir) ? publicDir : null,\n          redirects: project.config.redirects,\n        }))\n      );\n    } catch (error) {\n      if (error instanceof BlumeError) {\n        diagnostics.push(error.diagnostic);\n      } else {\n        reportInternalError(error);\n        process.exit(1);\n      }\n    }\n\n    // `--strict` escalates warnings to failures; info-level notes (e.g.\n    // BLUME_ASSETS_UNCHECKED when there is no public/ dir) stay advisory.\n    const strictFailure =\n      Boolean(args.strict) &&\n      diagnostics.some((diagnostic) => diagnostic.severity !== \"info\");\n\n    if (args.json) {\n      // Drain stdout before exiting non-zero: `process.exit` would otherwise\n      // truncate the JSON payload mid-write when stdout is a pipe — exactly how\n      // `--json` is consumed in CI/editors.\n      const hadErrors = reportDiagnosticsJson(diagnostics, root);\n      if (hadErrors || strictFailure) {\n        await flushStdout();\n        process.exit(1);\n      }\n      return;\n    }\n\n    const hadErrors = reportDiagnostics(diagnostics, root);\n    if (diagnostics.length === 0) {\n      logger.success(\"No broken links found.\");\n    }\n    if (hadErrors || strictFailure) {\n      process.exit(1);\n    }\n  },\n});\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAEA;AACA;AAqBO,IAAM,kBAAkB,cAAc;AAAA,EAC3C,MAAM;AAAA,IACJ,UAAU;AAAA,MACR,aAAa;AAAA,MACb,MAAM;AAAA,IACR;AAAA,IACA,MAAM;AAAA,MACJ,aAAa;AAAA,MACb,MAAM;AAAA,IACR;AAAA,IACA,QAAQ;AAAA,MACN,aAAa;AAAA,MACb,MAAM;AAAA,IACR;AAAA,EACF;AAAA,EACA,MAAM,YAAY;AAAA,OACZ,IAAG,GAAG,QAAQ;AAAA,IAClB,MAAM,OAAO,QAAQ,IAAI;AAAA,IACzB,MAAM,cAA4B,CAAC;AAAA,IAEnC,IAAI;AAAA,MACF,MAAM,UAAU,MAAM,YAAY,MAAM,EAAE,MAAM,QAAQ,CAAC;AAAA,MAGzD,YAAY,KAAK,GAAG,QAAQ,WAAW;AAAA,MAKvC,MAAM,YAAY,QAAQ,QAAQ,YAC9B,MAAM,cAAc,QAAQ,QAAQ,SAAS,IAC7C,CAAC;AAAA,MACL,MAAM,cAAc,mBAAmB,SAAS;AAAA,MAChD,IAAI,sBAAsB,SAAS,SAAS,GAAG;AAAA,QAC7C,YAAY,KAAK,YAAY;AAAA,MAC/B;AAAA,MAMA,IAAI,QAAQ,OAAO,MAAM;AAAA,QACvB,MAAM,WAAW,cAAc;AAAA,UAC7B,QAAQ,QAAQ;AAAA,UAChB,SAAS,QAAQ;AAAA,UACjB,OAAO,QAAQ;AAAA,QACjB,CAAC;AAAA,QACD,YAAY,KACV,GAAG,SAAS,OAAO,QAAQ,CAAC,UAC1B,MAAM,WAAW,CAAC,MAAM,IAAI,IAAI,CAAC,CACnC,CACF;AAAA,MACF;AAAA,MAEA,MAAM,YAAY,KAAK,MAAM,QAAQ;AAAA,MACrC,YAAY,KACV,GAAI,MAAM,cAAc,QAAQ,OAAO;AAAA,QACrC,UAAU,QAAQ,OAAO;AAAA,QACzB,eAAe,QAAQ,KAAK,QAAQ;AAAA,QACpC;AAAA,QACA,MAAM,QAAQ,OAAO;AAAA,QACrB,WAAW,WAAW,SAAS,IAAI,YAAY;AAAA,QAC/C,WAAW,QAAQ,OAAO;AAAA,MAC5B,CAAC,CACH;AAAA,MACA,OAAO,OAAO;AAAA,MACd,IAAI,iBAAiB,YAAY;AAAA,QAC/B,YAAY,KAAK,MAAM,UAAU;AAAA,MACnC,EAAO;AAAA,QACL,oBAAoB,KAAK;AAAA,QACzB,QAAQ,KAAK,CAAC;AAAA;AAAA;AAAA,IAMlB,MAAM,gBACJ,QAAQ,KAAK,MAAM,KACnB,YAAY,KAAK,CAAC,eAAe,WAAW,aAAa,MAAM;AAAA,IAEjE,IAAI,KAAK,MAAM;AAAA,MAIb,MAAM,YAAY,sBAAsB,aAAa,IAAI;AAAA,MACzD,IAAI,aAAa,eAAe;AAAA,QAC9B,MAAM,YAAY;AAAA,QAClB,QAAQ,KAAK,CAAC;AAAA,MAChB;AAAA,MACA;AAAA,IACF;AAAA,IAEA,MAAM,YAAY,kBAAkB,aAAa,IAAI;AAAA,IACrD,IAAI,YAAY,WAAW,GAAG;AAAA,MAC5B,OAAO,QAAQ,wBAAwB;AAAA,IACzC;AAAA,IACA,IAAI,aAAa,eAAe;AAAA,MAC9B,QAAQ,KAAK,CAAC;AAAA,IAChB;AAAA;AAEJ,CAAC;",
+  "debugId": "1EEBE4960D9C18F364756E2164756E21",
+  "names": []
+}

package/dist/cli/chunk-dh8cwk36.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+import {
+  BlumeError,
+  locateFrontmatterKey
+} from "./index.js";
+import {
+  ComponentOverridesError,
+  analyzeComponentOverrides
+} from "./chunk-vtk4a6dg.js";
+import {
+  frontmatter_default,
+  DEFAULT_CONTENT_INCLUDE,
+  DEFAULT_CONTENT_EXCLUDE,
+  pageMetaSchema,
+  createModuleLoader,
+  findConfigFile,
+  findComponentsFile,
+  ConfigValidationError,
+  loadConfig
+} from "./chunk-qkqwkpte.js";
+import {
+  baselineScanIgnore
+} from "./chunk-abh8yjkn.js";
+
+// src/upgrade/upgrade.ts
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { join, relative, resolve } from "pathe";
+import { glob } from "tinyglobby";
+import { z } from "zod";
+var UPGRADE_GUIDE_URL = "https://useblume.dev/docs/upgrading";
+var UPGRADE_GUIDE_FILE = join("docs", "03-upgrading.mdx");
+var DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies"
+];
+var RANGE_MAJOR = /^[\s<=>^~v]*(?<major>\d+)/u;
+var rangeMajor = (range) => {
+  const major = RANGE_MAJOR.exec(range)?.groups?.major;
+  return major === undefined ? null : Number(major);
+};
+var INDENT = /^(?<indent>[ \t]+)"/mu;
+var REGEXP_SPECIAL = /[$()*+.?[\\\]^{|}]/gu;
+var escapeRegExp = (value) => value.replaceAll(REGEXP_SPECIAL, String.raw`\$&`);
+var replaceRange = (text, field, from, to) => {
+  const value = JSON.stringify(from);
+  const entry = new RegExp(`"blume"\\s*:\\s*${escapeRegExp(value)}`, "gu");
+  entry.lastIndex = Math.max(text.indexOf(JSON.stringify(field)), 0);
+  const match = entry.exec(text);
+  if (!match) {
+    return null;
+  }
+  const end = match.index + match[0].length;
+  return `${text.slice(0, end - value.length)}${JSON.stringify(to)}${text.slice(end)}`;
+};
+var bumpBlumeDependency = async (root, version) => {
+  const path = join(root, "package.json");
+  if (!existsSync(path)) {
+    return { status: "missing" };
+  }
+  const text = await readFile(path, "utf-8");
+  const pkg = JSON.parse(text);
+  const field = DEPENDENCY_FIELDS.find((name) => pkg[name]?.blume !== undefined);
+  const from = field ? pkg[field]?.blume : undefined;
+  if (!(field && from)) {
+    return { status: "missing" };
+  }
+  const current = rangeMajor(from);
+  const target = rangeMajor(version);
+  if (current === null || target === null || current >= target) {
+    return { range: from, status: "current" };
+  }
+  const to = `^${version}`;
+  const indent = INDENT.exec(text)?.groups?.indent ?? "  ";
+  const updated = { ...pkg, [field]: { ...pkg[field], blume: to } };
+  await writeFile(path, replaceRange(text, field, from, to) ?? `${JSON.stringify(updated, null, indent)}
+`);
+  return { field, from, status: "bumped", to };
+};
+var isOutsideBlumeProject = (root, bump) => bump.status === "missing" && findConfigFile(root) === null;
+var REMOVED_BUILD_FLAG = /^--(?<flag>adapter|base|output)(?:=|$)/u;
+var removedBuildFlags = (args) => [
+  ...new Set(args.flatMap((arg) => {
+    const flag = REMOVED_BUILD_FLAG.exec(arg)?.groups?.flag;
+    return flag ? [flag] : [];
+  }))
+];
+var flagList = (flags) => flags.map((flag) => `--${flag}`).join(", ");
+var removedBuildFlagsAdvice = (flags) => {
+  const advice = [];
+  if (flags.includes("adapter") || flags.includes("output")) {
+    advice.push('name the host in blume.config.ts with `deployment: vercel()` (or `netlify()`, `cloudflare()`, `node()`) from "blume/deploy" — a host adapter builds for the server, and `output: "static"` keeps it static');
+  }
+  if (flags.includes("base")) {
+    advice.push('set the subpath with `deployment: { base: "/docs" }`, or the host adapter\'s `base` option');
+  }
+  return `Drop ${flagList(flags)} and ${advice.join("; ")}.`;
+};
+var BLUME_BIN = /(?:^|[/\\])blume(?:@\S+)?$/u;
+var COMMAND_SEPARATOR = /&&|\|\||[;|]/u;
+var WHITESPACE = /\s+/u;
+var buildArgs = (script) => script.split(COMMAND_SEPARATOR).flatMap((command) => {
+  const words = command.trim().split(WHITESPACE);
+  const at = words.findIndex((word, index) => BLUME_BIN.test(word) && words[index + 1] === "build");
+  return at === -1 ? [] : words.slice(at + 2);
+});
+var scriptsSchema = z.looseObject({
+  scripts: z.record(z.string(), z.string()).default({})
+});
+var lineOf = (text, index) => text.slice(0, index).split(`
+`).length;
+var scriptFindings = async (root) => {
+  const path = join(root, "package.json");
+  if (!existsSync(path)) {
+    return [];
+  }
+  const text = await readFile(path, "utf-8");
+  const pkg = scriptsSchema.safeParse(JSON.parse(text));
+  const scripts = pkg.success ? pkg.data.scripts : {};
+  const scriptsAt = text.indexOf('"scripts"');
+  return Object.entries(scripts).flatMap(([name, script]) => {
+    const flags = removedBuildFlags(buildArgs(script));
+    if (flags.length === 0) {
+      return [];
+    }
+    const at = text.indexOf(JSON.stringify(name), scriptsAt);
+    return [
+      {
+        code: "BLUME_BUILD_FLAG_REMOVED",
+        file: path,
+        line: at === -1 ? undefined : lineOf(text, at),
+        message: `The "${name}" script passes ${flagList(flags)} to \`blume build\`, which Blume 2 removed.`,
+        severity: "error",
+        suggestion: removedBuildFlagsAdvice(flags)
+      }
+    ];
+  });
+};
+var globFields = {
+  exclude: z.array(z.string()).optional(),
+  include: z.array(z.string()).optional(),
+  root: z.string().optional()
+};
+var rawFilesystemSourceSchema = z.union([
+  z.looseObject({
+    kind: z.literal("filesystem"),
+    options: z.looseObject(globFields).default({})
+  }).transform((source) => source.options),
+  z.looseObject({ type: z.literal("filesystem"), ...globFields })
+]);
+var rawContentSchema = z.looseObject({
+  content: z.looseObject({ ...globFields, sources: z.array(z.unknown()).optional() }).optional()
+});
+var contentGlobs = ({
+  content
+}) => {
+  const sources = (content?.sources ?? []).flatMap((source) => {
+    const filesystem = rawFilesystemSourceSchema.safeParse(source);
+    return filesystem.success ? [filesystem.data] : [];
+  });
+  return (sources.length > 0 ? sources : [content ?? {}]).map((globs) => ({
+    exclude: globs.exclude ?? DEFAULT_CONTENT_EXCLUDE,
+    include: globs.include ?? DEFAULT_CONTENT_INCLUDE,
+    root: globs.root ?? "docs"
+  }));
+};
+var configContentGlobs = async (root) => {
+  const file = findConfigFile(root);
+  let raw = {};
+  if (file) {
+    try {
+      const parsed = rawContentSchema.safeParse(await createModuleLoader()(file));
+      raw = parsed.success ? parsed.data : {};
+    } catch {}
+  }
+  return contentGlobs(raw);
+};
+var isPathKey = (segment) => typeof segment !== "symbol";
+var PLAIN_UNKNOWN_KEY = "Unrecognized key";
+var removedFieldFindings = (file, text, issues) => issues.flatMap((issue) => {
+  if (issue.code !== "unrecognized_keys" || issue.message.startsWith(PLAIN_UNKNOWN_KEY)) {
+    return [];
+  }
+  const path = issue.path.filter(isPathKey);
+  const position = locateFrontmatterKey(text, [...path, ...issue.keys.slice(0, 1)]) ?? locateFrontmatterKey(text, path);
+  return [
+    {
+      code: "BLUME_FRONTMATTER_INVALID",
+      column: position?.column,
+      file,
+      line: position?.line,
+      message: issue.message,
+      severity: "error"
+    }
+  ];
+});
+var pageFindings = async (file) => {
+  const text = await readFile(file, "utf-8");
+  let parsed;
+  try {
+    parsed = pageMetaSchema.safeParse(frontmatter_default(text).data);
+  } catch {
+    return [];
+  }
+  return parsed.success ? [] : removedFieldFindings(file, text, parsed.error.issues);
+};
+var frontmatterFindings = async (root) => {
+  const roots = await configContentGlobs(root);
+  const matches = await Promise.all(roots.map((globs) => {
+    const cwd = resolve(root, globs.root);
+    return existsSync(cwd) ? glob(globs.include, {
+      absolute: true,
+      cwd,
+      ignore: [...globs.exclude, ...baselineScanIgnore()],
+      onlyFiles: true
+    }) : [];
+  }));
+  const files = [...new Set(matches.flat())].toSorted();
+  const findings = await Promise.all(files.map(pageFindings));
+  return findings.flat();
+};
+var findingsOf = async (check) => {
+  try {
+    await check();
+    return [];
+  } catch (error) {
+    if (error instanceof ConfigValidationError || error instanceof ComponentOverridesError) {
+      return error.issues;
+    }
+    if (error instanceof BlumeError) {
+      return [error.diagnostic];
+    }
+    throw error;
+  }
+};
+var collectUpgradeFindings = async (root) => {
+  const componentsFile = findComponentsFile(root);
+  return [
+    ...await findingsOf(async () => {
+      await loadConfig(root);
+    }),
+    ...componentsFile ? await findingsOf(async () => {
+      analyzeComponentOverrides(await readFile(componentsFile, "utf-8"), componentsFile);
+    }) : [],
+    ...await frontmatterFindings(root),
+    ...await scriptFindings(root)
+  ];
+};
+var plainFinding = (finding, root) => {
+  const where = finding.file ? `${relative(root, finding.file)}${finding.line === undefined ? "" : `:${finding.line}`}` : "blume.config.ts";
+  const fix = finding.suggestion ? `
+  Fix: ${finding.suggestion}` : "";
+  return `- ${where} (${finding.code})
+  ${finding.message.replaceAll(`
+`, `
+  `)}${fix}`;
+};
+var upgradePrompt = (options) => `Upgrade this Blume project to Blume ${options.version}. \`blume upgrade\` has bumped the \`blume\` dependency in package.json where it could; what's left is the config.
+
+The upgrade guide is at ${options.guidePath} (online at ${UPGRADE_GUIDE_URL}). It covers every change between Blume 1 and 2 with before-and-after examples: search, deployment, content sources, API references, analytics, and the assistant's model provider become adapters imported from \`blume/*\` subpaths; the machine-readable settings move from \`ai\` to \`agents\`; Ask AI is renamed the assistant, so \`ai.ask\` becomes \`ai.assistant\`; and \`components.ts\` entries must be one of the static forms.
+
+\`blume upgrade\` found:
+
+${options.findings.map((finding) => plainFinding(finding, options.root)).join(`
+
+`)}
+
+Work through every finding:
+1. Read the guide section for each change before editing.
+2. Rewrite the config to the Blume 2 form, adding the adapter imports it needs. Keep the site's behavior the same: the same content, routes, search backend, deployment target, analytics, and credentials (keep reading secrets from the same environment variables).
+3. The config loader reports every invalid field at once, but some changes only surface once earlier ones are fixed, so rerun \`${options.runner} blume doctor\` after each round of edits.
+4. Never delete content, or remove a setting only to silence an error; if something needs a human decision, leave it and say so in your summary.
+
+When \`${options.runner} blume doctor\` reports no errors, run \`${options.runner} blume build\` and fix anything it reports until it succeeds.`;
+
+export { UPGRADE_GUIDE_URL, UPGRADE_GUIDE_FILE, bumpBlumeDependency, isOutsideBlumeProject, removedBuildFlags, flagList, removedBuildFlagsAdvice, collectUpgradeFindings, upgradePrompt };
+
+//# debugId=9BE967FC7391289164756E2164756E21
+//# sourceMappingURL=chunk-dh8cwk36.js.map