blume 2.1.0 → 2.1.1

package/src/core/ui-packs/uk.ts

@@ -50,6 +50,7 @@ export const uk: UIStringsOverride = {
   banner: { dismiss: "Закрити оголошення" },
   changelog: {
     description: "Оновлення продукту та примітки до випусків.",
+    empty: "У журналі змін поки немає записів.",
     title: "Журнал змін",
   },
   consent: {

package/src/core/ui-packs/vi.ts

@@ -49,6 +49,7 @@ export const vi: UIStringsOverride = {
   banner: { dismiss: "Đóng thông báo" },
   changelog: {
     description: "Cập nhật sản phẩm và ghi chú phát hành.",
+    empty: "Chưa có mục nào trong nhật ký thay đổi.",
     title: "Nhật ký thay đổi",
   },
   consent: {

package/src/core/ui-packs/zh-tw.ts

@@ -48,6 +48,7 @@ export const zhTW: UIStringsOverride = {
   banner: { dismiss: "關閉公告" },
   changelog: {
     description: "產品更新與版本說明。",
+    empty: "尚無更新日誌項目。",
     title: "更新日誌",
   },
   consent: {

package/src/core/ui-packs/zh.ts

@@ -48,6 +48,7 @@ export const zh: UIStringsOverride = {
   banner: { dismiss: "关闭公告" },
   changelog: {
     description: "产品更新与版本说明。",
+    empty: "暂无更新日志条目。",
     title: "更新日志",
   },
   consent: {

package/src/deploy/adapter-output.ts

@@ -3,6 +3,7 @@ import { cp, mkdir, rm } from "node:fs/promises";
 
 import { dirname, join } from "pathe";
 
+import { normalizeBasePath } from "../core/base-path.ts";
 import type { ResolvedConfig } from "../core/schema.ts";
 import type { ProjectContext } from "../core/types.ts";
 import type { ResolvedDeployment } from "./adapters/registry.ts";
@@ -30,7 +31,8 @@ export const deployOutputDir = (
  * served. A static build serves `dist/` wherever it lands; a server build
  * serves what its platform declares — the Build Output tree's `static/` half
  * on Vercel, Astro's `build.client` dir (`dist/client/`) on Node and
- * Cloudflare, `dist/` on Netlify.
+ * Cloudflare, `dist/` on Netlify. On Vercel and Cloudflare that's its
+ * `<base>/` directory under `deployment.base`, where the files land.
  */
 export const deployStaticDir = (
   config: ResolvedConfig,
@@ -38,7 +40,10 @@ export const deployStaticDir = (
 ): string => {
   const { deployment } = config;
   return deployment.options.output === "server"
-    ? deployPlatform(deployment).serverStaticDir(context)
+    ? deployPlatform(deployment).serverStaticDir(
+        context,
+        normalizeBasePath(deployment.options.base)
+      )
     : distDir(context);
 };
 

package/src/deploy/adapters/cloudflare.ts

@@ -23,11 +23,13 @@ export const cloudflareAdapterSchema = adapterDescriptorSchema(
 );
 
 /**
- * Cloudflare Workers and Pages. A server build emits a Worker into
- * `dist/server` (with a generated wrapper that answers `Accept:
- * text/markdown`) and serves `dist/client` through the ASSETS binding.
- * `@astrojs/cloudflare` is an optional peer: install it in the project
- * (`npm install @astrojs/cloudflare`).
+ * Cloudflare. A server build targets Workers only (`@astrojs/cloudflare`
+ * dropped Pages in v13): it emits a Worker into `dist/server` (with a
+ * generated wrapper that answers `Accept: text/markdown`) and serves
+ * `dist/client` through the ASSETS binding. A static build
+ * (`output: "static"`) never loads the adapter, and its `dist/` deploys to
+ * Pages or to Workers static assets. `@astrojs/cloudflare` is an optional
+ * peer: install it in the project (`npm install @astrojs/cloudflare`).
  */
 export const cloudflare = (
   options: CloudflareOptions = {}

package/src/deploy/adapters/node.ts

@@ -1,3 +1,5 @@
+import { z } from "zod";
+
 import { adapterDescriptorSchema } from "../../core/adapter.ts";
 import type { DeployAdapter, DeployOptions } from "./types.ts";
 import { deployOptionsSchema, serverRuntimeDeps } from "./types.ts";
@@ -6,18 +8,54 @@ import { deployOptionsSchema, serverRuntimeDeps } from "./types.ts";
 export const NODE_ADAPTER_PACKAGE = "@astrojs/node";
 
 /**
- * Options for {@link node}: `output`, `site`, and `base`, plus any option of
- * `@astrojs/node` forwarded verbatim (`mode`, `staticHeaders`, …). Blume
- * defaults `mode` to `"standalone"`; an option you pass wins. `host` and
- * `port` are forwarded too, but `@astrojs/node` replaces both with Astro's
- * own server settings, so the standalone server listens on `localhost:4321`
- * unless the `HOST` and `PORT` environment variables are set when it starts.
+ * A host the server trusts forwarded headers for, in Astro's
+ * `security.allowedDomains` shape: each field set must match.
  */
-export type NodeOptions = DeployOptions;
+// oxlint-disable-next-line typescript/consistent-type-definitions -- interface loses the implicit index signature a deploy option's JsonValue needs
+export type NodeAllowedDomain = {
+  /** The host, like `docs.example.com`; `*.example.com` matches subdomains. */
+  hostname?: string;
+  /** The port, as a string. */
+  port?: string;
+  /** The scheme, like `https`. */
+  protocol?: string;
+};
 
-export type NodeAdapter = DeployAdapter<"node">;
+/**
+ * Options for {@link node}: `output`, `site`, `base`, and `allowedDomains`,
+ * plus any option of `@astrojs/node` forwarded verbatim (`mode`,
+ * `staticHeaders`, …). Blume defaults `mode` to `"standalone"`; an option you
+ * pass wins. `host` and `port` are forwarded too, but `@astrojs/node`
+ * replaces both with Astro's own server settings, so the standalone server
+ * listens on `localhost:4321` unless the `HOST` and `PORT` environment
+ * variables are set when it starts.
+ */
+export type NodeOptions = DeployOptions & {
+  /**
+   * The hosts a reverse proxy in front of the server answers for, set as
+   * Astro's `security.allowedDomains`. A request whose `Host` (or
+   * `X-Forwarded-Host`) matches one is trusted to name the reader in
+   * `X-Forwarded-For`, which the rate limit counts by; otherwise every
+   * reader counts as the proxy's address. Only list them when a proxy sets
+   * that header on every request, since a reader could otherwise send their
+   * own.
+   */
+  allowedDomains?: NodeAllowedDomain[];
+};
 
-export const nodeOptionsSchema = deployOptionsSchema;
+export type NodeAdapter = DeployAdapter<"node", NodeOptions>;
+
+export const nodeOptionsSchema = deployOptionsSchema.extend({
+  allowedDomains: z
+    .array(
+      z.strictObject({
+        hostname: z.string().min(1).optional(),
+        port: z.string().min(1).optional(),
+        protocol: z.string().min(1).optional(),
+      })
+    )
+    .optional(),
+});
 
 export const nodeAdapterSchema = adapterDescriptorSchema(
   "node",

package/src/deploy/adapters/types.ts

@@ -84,13 +84,17 @@ const NAMED_OPTIONS = new Set(["base", "output", "site"]);
 
 /**
  * The options Blume does not name — what reaches the `@astrojs/*` adapter's
- * constructor verbatim.
+ * constructor verbatim. `configOptions` are the ones a host adapter names
+ * itself, for the Astro config rather than the constructor.
  */
 export const deployPassthrough = (
-  options: DeployOptions
+  options: DeployOptions,
+  configOptions: readonly string[] = []
 ): Record<string, JsonValue> =>
   Object.fromEntries(
-    Object.entries(options).filter(([key]) => !NAMED_OPTIONS.has(key))
+    Object.entries(options).filter(
+      ([key]) => !(NAMED_OPTIONS.has(key) || configOptions.includes(key))
+    )
   );
 
 /**

package/src/deploy/artifacts.ts

@@ -445,7 +445,8 @@ export const publishBuildArtifacts = async (
   await buildNarration(project, distDir, logger);
 
   // Upload the index to a hosted provider (Algolia, Orama Cloud, Typesense).
-  // Skipped with a warning when its admin key isn't configured.
+  // Skipped with a warning when its admin key isn't configured; with the key
+  // set, a failed sync fails the build.
   await syncSearchProvider(project, {
     start: logger.info.bind(logger),
     success: logger.info.bind(logger),

package/src/deploy/platforms/cloudflare.ts

@@ -305,17 +305,21 @@ export const bindCloudflareRateLimit = async (
 };
 
 /**
- * Cloudflare Workers and Pages. A server build emits the Worker into
- * `dist/server` and serves `dist/client` through the ASSETS binding, which
- * honors `_headers` from that directory exactly as Pages does — so the file
- * applies to both output modes here. Without a configured driver the adapter
- * force-enables KV-backed sessions and declares a `SESSION` binding that
- * `wrangler deploy` then demands a namespace for, even though Blume never
- * reads `Astro.session`; `session: false` opts the project out.
+ * Cloudflare. A server build targets Workers only (`@astrojs/cloudflare`
+ * dropped Pages in v13): it emits the Worker into `dist/server` and serves
+ * `dist/client` through the ASSETS binding, which honors `_headers` from that
+ * directory exactly as Pages does — so the file applies to both output modes
+ * here. A static build never loads the adapter; its `dist/` deploys to Pages,
+ * whose build environment `env` detects, or to Workers static assets (Workers
+ * Builds exposes no site URL to detect). Without a configured driver the
+ * adapter force-enables KV-backed sessions and declares a `SESSION` binding
+ * that `wrangler deploy` then demands a namespace for, even though Blume
+ * never reads `Astro.session`; `session: false` opts the project out.
  */
 export const cloudflarePlatform: DeployPlatform = {
   astro: {
-    config: { session: false },
+    config: () => ({ session: false }),
+    configOptions: [],
     options: adapterOptions,
     package: CLOUDFLARE_ADAPTER_PACKAGE,
   },
@@ -350,5 +354,5 @@ export const cloudflarePlatform: DeployPlatform = {
   // build, and hoists its own `_headers`/`_redirects` back up to `dist/client`.
   serverClientUnderBase: true,
   serverOutputDir: distDir,
-  serverStaticDir: clientDir,
+  serverStaticDir: (context, base) => join(clientDir(context), base),
 };

package/src/deploy/platforms/netlify.ts

@@ -118,7 +118,8 @@ export const emitNetlifyPatternRedirects = async (
  */
 export const netlifyPlatform: DeployPlatform = {
   astro: {
-    config: {},
+    config: () => ({}),
+    configOptions: [],
     options: () => ({}),
     package: NETLIFY_ADAPTER_PACKAGE,
   },

package/src/deploy/platforms/node.ts

@@ -1,3 +1,4 @@
+import type { JsonValue } from "../../core/adapter.ts";
 import { NODE_ADAPTER_PACKAGE } from "../adapters/node.ts";
 import { wrapNodeEntry } from "../node-headers.ts";
 import { clientDir, distDir } from "./paths.ts";
@@ -11,11 +12,20 @@ import type { DeployPlatform } from "./types.ts";
  * discovery files and downloaded SVGs need instead, and answers the
  * configured redirects with their exact status, which Astro's own handler
  * would default to 301 or 308. No platform env to detect: the site URL has to
- * be configured.
+ * be configured. `allowedDomains` becomes Astro's `security.allowedDomains`,
+ * which a server behind a reverse proxy needs before Astro reads the reader's
+ * address from `X-Forwarded-For`.
  */
 export const nodePlatform: DeployPlatform = {
   astro: {
-    config: {},
+    config: ({ allowedDomains }) => {
+      const config: Record<string, JsonValue> = {};
+      if (allowedDomains) {
+        config.security = { allowedDomains };
+      }
+      return config;
+    },
+    configOptions: ["allowedDomains"],
     options: () => ({ mode: "standalone" }),
     package: NODE_ADAPTER_PACKAGE,
   },

package/src/deploy/platforms/types.ts

@@ -2,7 +2,10 @@ import type { JsonValue } from "../../core/adapter.ts";
 import type { BlumeProject } from "../../core/project-graph.ts";
 import type { ResolvedConfig } from "../../core/schema.ts";
 import type { ProjectContext } from "../../core/types.ts";
-import type { DeployAdapterKind } from "../adapters/registry.ts";
+import type {
+  DeployAdapterKind,
+  ResolvedDeployOptions,
+} from "../adapters/registry.ts";
 import type { DeployOutput } from "../adapters/types.ts";
 
 /**
@@ -15,8 +18,16 @@ import type { DeployOutput } from "../adapters/types.ts";
 
 /** How the generated `astro.config.mjs` constructs the `@astrojs/*` adapter. */
 export interface AstroAdapterSpec {
-  /** Top-level `defineConfig` entries the adapter needs beside itself. */
-  config: Record<string, JsonValue>;
+  /**
+   * Top-level `defineConfig` entries the adapter needs beside itself, some
+   * of them set from the deployment's own options.
+   */
+  config: (options: ResolvedDeployOptions) => Record<string, JsonValue>;
+  /**
+   * The deployment options `config` reads, which therefore stay out of the
+   * passthrough to the `@astrojs/*` constructor.
+   */
+  configOptions: string[];
   /** Blume's own constructor options; the user's passthrough is spread over them. */
   options: (context: ProjectContext) => Record<string, JsonValue>;
   /** The package the config imports the adapter from. */
@@ -115,13 +126,16 @@ export interface DeployPlatform {
   /**
    * Whether the adapter moves a server build's client output under
    * `deployment.base` (`dist/client/<base>/`, the directory Astro then hands
-   * `astro:build:done`) while the platform keeps serving `serverStaticDir`
-   * as the assets root. The files the platform reads there, like `_headers`,
+   * `astro:build:done`) while the platform keeps serving `dist/client` as
+   * the assets root. The files the platform reads there, like `_headers`,
    * belong above the directory Astro reports.
    */
   serverClientUnderBase: boolean;
   /** Where a server build's deploy bundle lands. */
   serverOutputDir: (context: ProjectContext) => string;
-  /** The directory a server build serves as static files. */
-  serverStaticDir: (context: ProjectContext) => string;
+  /**
+   * The directory a server build serves as static files, given the normalized
+   * `deployment.base` for a platform that serves them from `<dir>/<base>/`.
+   */
+  serverStaticDir: (context: ProjectContext, base: string) => string;
 }

package/src/deploy/platforms/vercel.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 
-import { join } from "pathe";
+import { dirname, join } from "pathe";
 
 import { crossOriginDiscoveryPaths } from "../../ai/ai-catalog.ts";
 import {
@@ -20,7 +20,10 @@ import {
   SIGNATURES_DIRECTORY_PATH,
   SIGNATURES_DIRECTORY_TYPE,
 } from "../../ai/web-bot-auth.ts";
+import { mountBasePath, normalizeBasePath } from "../../core/base-path.ts";
 import type { BlumeProject } from "../../core/project-graph.ts";
+import { isPatternPath, regexRedirect } from "../../core/redirect-patterns.ts";
+import type { ResolvedConfig } from "../../core/schema.ts";
 import type { ProjectContext } from "../../core/types.ts";
 import { VERCEL_ADAPTER_PACKAGE } from "../adapters/vercel.ts";
 import {
@@ -37,7 +40,9 @@ import {
 import {
   injectNegotiationRoutes,
   injectRedirectRoutes,
+  rebaseAdapterRoutes,
 } from "../vercel-negotiation.ts";
+import type { VercelRoute } from "../vercel-negotiation.ts";
 import { adapterRoot, toSiteUrl } from "./paths.ts";
 import type { BuildLog, DeployPlatform, RedirectFile } from "./types.ts";
 
@@ -56,6 +61,14 @@ export const VERCEL_JSON_FILE: RedirectFile = {
 const buildOutputDir = (context: ProjectContext): string =>
   join(adapterRoot(context), ".vercel", "output");
 
+/** The static files a server build serves, under the base's directory. */
+const staticDir = (context: ProjectContext, base: string): string =>
+  join(buildOutputDir(context), "static", base);
+
+/** The project's normalized `deployment.base`, `""` for none. */
+const deploymentBase = (project: BlumeProject): string =>
+  normalizeBasePath(project.config.deployment.options.base);
+
 /**
  * Refuse to ship a function bundle that would crash at runtime: a bare import
  * the adapter's dependency trace silently dropped (see
@@ -99,18 +112,21 @@ export const emitVercelNegotiation = async (
   log: BuildLog
 ): Promise<void> => {
   const { config, context } = project;
-  const outputDir = buildOutputDir(context);
-  const configPath = join(outputDir, "config.json");
+  const configPath = join(buildOutputDir(context), "config.json");
   if (!existsSync(configPath)) {
     return;
   }
+  const base = deploymentBase(project);
   const routePaths = markdownRoutePaths(project);
+  // Keyed by the file's path in `static/`, under the base's directory.
   const overrides: Record<string, string> = {};
   if (hasApiCatalog(config)) {
-    overrides[API_CATALOG_PATH.slice(1)] = API_CATALOG_TYPE;
+    overrides[mountBasePath(base, API_CATALOG_PATH).slice(1)] =
+      API_CATALOG_TYPE;
   }
   if (config.agents.webBotAuth.keys.length > 0) {
-    overrides[SIGNATURES_DIRECTORY_PATH.slice(1)] = SIGNATURES_DIRECTORY_TYPE;
+    overrides[mountBasePath(base, SIGNATURES_DIRECTORY_PATH).slice(1)] =
+      SIGNATURES_DIRECTORY_TYPE;
   }
   // The homepage rewrite serves `/index.md` from the static layer, so its
   // `x-markdown-tokens` estimate has to ride the routing config; the runtime
@@ -120,7 +136,7 @@ export const emitVercelNegotiation = async (
   // The Markdown and JSON 404 routes point at the prerendered twins; only
   // wire each when the build actually emitted it (a project that owns `/404`
   // gets none).
-  const staticDir = join(outputDir, "static");
+  const builtDir = staticDir(context, base);
   const injected = injectNegotiationRoutes(
     await readFile(configPath, "utf-8"),
     routePaths,
@@ -128,13 +144,14 @@ export const emitVercelNegotiation = async (
     overrides,
     home ? markdownTokenCount(agentMarkdown(home)) : undefined,
     {
-      json: existsSync(join(staticDir, "404.json")),
-      markdown: existsSync(join(staticDir, "404.md")),
+      json: existsSync(join(builtDir, "404.json")),
+      markdown: existsSync(join(builtDir, "404.md")),
     },
     crossOriginDiscoveryPaths(config),
     // Downloaded content assets are prerendered static files; only a build
     // that has them needs the SVG sandbox route.
-    existsSync(join(staticDir, "blume-assets"))
+    existsSync(join(builtDir, "blume-assets")),
+    base
   );
   if (injected === null) {
     log.warn(
@@ -175,6 +192,76 @@ export const emitVercelPatternRedirects = async (
   await writeFile(configPath, injected, "utf-8");
 };
 
+type Redirect = ResolvedConfig["redirects"][number];
+
+/**
+ * The exact redirects as Build Output routes, matched the way the pattern ones
+ * are (see `regexRedirect`): the served path, a trailing slash optional.
+ */
+const exactRedirectRoutes = (redirects: Redirect[]): VercelRoute[] =>
+  redirects
+    .filter((redirect) => !isPatternPath(redirect.from))
+    .map(({ from, status, to }) => ({
+      headers: { Location: encodeURI(to) },
+      src: regexRedirect({ parts: [{ kind: "text", text: from }], status, to })
+        .source,
+      status,
+    }));
+
+/**
+ * Move a server build's static files under `deployment.base`.
+ * `@astrojs/vercel` copies them to the root of the Build Output tree's
+ * `static/`, while the pages request `<base>/_astro/…` and link to
+ * `<base>/…`, so nothing the site asks for would be found. Moved to
+ * `static/<base>/`, they're served at the base, as the routes that
+ * {@link rebaseVercelRoutes} moves there expect.
+ */
+export const moveStaticUnderBase = async (
+  context: ProjectContext,
+  base: string
+): Promise<void> => {
+  const root = staticDir(context, "");
+  if (!base || !existsSync(root)) {
+    return;
+  }
+  // Through a sibling, since the target lies inside the directory it moves.
+  const staging = join(buildOutputDir(context), "static-unbased");
+  await rename(root, staging);
+  const target = staticDir(context, base);
+  await mkdir(dirname(target), { recursive: true });
+  await rename(staging, target);
+};
+
+/**
+ * Move the adapter's routing config under `deployment.base` to match the
+ * static files (see `rebaseAdapterRoutes`), its exact redirects rebuilt from
+ * the configured ones. Resolves to false when the config can't be read: the
+ * adapter's routes would then miss every path under the base.
+ */
+export const rebaseVercelRoutes = async (
+  project: BlumeProject,
+  log: BuildLog
+): Promise<boolean> => {
+  const base = deploymentBase(project);
+  const configPath = join(buildOutputDir(project.context), "config.json");
+  if (!base || !existsSync(configPath)) {
+    return true;
+  }
+  const rebased = rebaseAdapterRoutes(
+    await readFile(configPath, "utf-8"),
+    base,
+    exactRedirectRoutes(platformRedirects(project))
+  );
+  if (rebased === null) {
+    log.error(
+      `Could not move the routes in .vercel/output/config.json under the deployment base "${base}", so the site would not be served there.`
+    );
+    return false;
+  }
+  await writeFile(configPath, rebased, "utf-8");
+  return true;
+};
+
 /**
  * Vercel. A server build's Build Output tree lands at `.vercel/output` — at
  * the project root, because the adapter is handed that root up front: its
@@ -183,11 +270,14 @@ export const emitVercelPatternRedirects = async (
  * Static assets are served from the tree's `static/` half, so the deploy
  * artifacts are written there; headers (the discovery files', the sandbox on
  * downloaded SVGs) arrive through the routing config rather than a
- * `_headers` file, which Vercel never reads.
+ * `_headers` file, which Vercel never reads. The adapter ignores
+ * `deployment.base`, so under one the build moves the static files and the
+ * routes beneath it.
  */
 export const vercelPlatform: DeployPlatform = {
   astro: {
-    config: {},
+    config: () => ({}),
+    configOptions: [],
     options: () => ({}),
     package: VERCEL_ADAPTER_PACKAGE,
   },
@@ -210,12 +300,19 @@ export const vercelPlatform: DeployPlatform = {
     if (!ok) {
       return false;
     }
+    // A verify build moves its static files too, where the budget gate reads
+    // them (`serverStaticDir`).
+    await moveStaticUnderBase(context, deploymentBase(project));
     // An isolated verify only proves the bundle would ship; the routing
     // config is a deploy artifact and stays untouched.
-    if (!isolated) {
-      await emitVercelNegotiation(project, log);
-      await emitVercelPatternRedirects(project, log);
+    if (isolated) {
+      return true;
+    }
+    if (!(await rebaseVercelRoutes(project, log))) {
+      return false;
     }
+    await emitVercelNegotiation(project, log);
+    await emitVercelPatternRedirects(project, log);
     return true;
   },
   hiddenRuntime: {
@@ -231,5 +328,5 @@ export const vercelPlatform: DeployPlatform = {
   redirectFiles: [VERCEL_JSON_FILE],
   serverClientUnderBase: false,
   serverOutputDir: buildOutputDir,
-  serverStaticDir: (context) => join(buildOutputDir(context), "static"),
+  serverStaticDir: staticDir,
 };

package/src/deploy/redirects.ts

@@ -1,5 +1,7 @@
 import {
   normalizeBasePath,
+  normalizePath,
+  stripBasePath,
   withAuthoredBasePath,
   withBasePath,
   withComposedBasePath,
@@ -11,6 +13,7 @@ import {
   compileRedirects,
   exactFirst,
   expandRedirect,
+  isPatternPath,
   underscoreRedirect,
   vercelRedirect,
 } from "../core/redirect-patterns.ts";
@@ -109,9 +112,60 @@ export const applyBaseToPlatformRedirects = (
     : redirects;
 };
 
+/**
+ * The raw-Markdown copies Blume serves beside every page (`/guide.md`,
+ * `/guide.mdx`; see `rawMarkdownEndpointTemplate`).
+ */
+const MIRROR_EXTENSIONS = [".md", ".mdx"] as const;
+
+/**
+ * Where a page's Markdown copy is served, from the page's served path and the
+ * deployment base that path carries: the endpoints name the root `index`.
+ */
+const mirrorPath = (path: string, base: string, extension: string): string => {
+  const route = stripBasePath(base, path);
+  return `${base}${route === "/" ? "/index" : route}${extension}`;
+};
+
+/**
+ * Based `redirects`, each exact one that moves a page followed by the same
+ * redirect for the page's Markdown copies: from a path no page is served at
+ * to one a page is, `/old.md` goes to `/new.md` (and `.mdx` alike), where it
+ * would otherwise 404 for an agent still reading the old URL. A pattern gets
+ * none; one that carries its capture over (`/beta/:slug*` → `/v2/:slug*`)
+ * already moves `/beta/guide.md` along. `pages` are the served page routes
+ * (carrying `basePath`, not `deployment.base`), and `bases` the deployment
+ * base each end carries: Astro's config leaves it off `from` (see
+ * {@link applyBaseToAstroRedirects}).
+ */
+export const withMirrorRedirects = (
+  redirects: Redirect[],
+  pages: RouteSet,
+  bases: { from: string; to: string }
+): Redirect[] =>
+  redirects.flatMap((redirect) => {
+    const from = normalizePath(redirect.from);
+    const to = normalizePath(redirect.to);
+    const movesPage =
+      !isPatternPath(redirect.from) &&
+      servesRoute(pages, stripBasePath(bases.to, to)) &&
+      !servesRoute(pages, stripBasePath(bases.from, from));
+    return movesPage
+      ? [
+          redirect,
+          ...MIRROR_EXTENSIONS.map((extension) => ({
+            from: mirrorPath(from, bases.from, extension),
+            status: redirect.status,
+            to: mirrorPath(to, bases.to, extension),
+          })),
+        ]
+      : [redirect];
+  });
+
 /**
  * The configured redirects as the host platform matches them, via
- * {@link applyBaseToPlatformRedirects}, exact paths ahead of patterns: hosts
+ * {@link applyBaseToPlatformRedirects} plus the Markdown copies of each moved
+ * page ({@link withMirrorRedirects}), exact paths ahead of patterns: hosts
  * try rules in order, and an exact redirect wins over a pattern that also
  * covers its path. The one basing every consumer must share: the emitted
  * redirect files and the server wrappers all compare these paths against
@@ -122,12 +176,18 @@ export const platformRedirects = (project: {
   manifest: Pick<BlumeProject["manifest"], "routes">;
 }): Redirect[] => {
   const { config } = project;
+  const base = normalizeBasePath(config.deployment.options.base);
+  const pages = routeSetFor(project.manifest.routes);
   return exactFirst(
-    applyBaseToPlatformRedirects(
-      config.redirects,
-      config.basePath,
-      config.deployment.options.base ?? "",
-      routeSetFor(project.manifest.routes)
+    withMirrorRedirects(
+      applyBaseToPlatformRedirects(
+        config.redirects,
+        config.basePath,
+        base,
+        pages
+      ),
+      pages,
+      { from: base, to: base }
     )
   );
 };

package/src/deploy/rss.ts

@@ -78,7 +78,9 @@ export const buildRssFeeds = (project: BlumeProject): RssFeed[] => {
     const items: RssItem[] = pages
       .map((page) => ({
         date: pageDate(page),
-        description: page.description,
+        // A page with only a meta description (a GitHub release, whose
+        // summary goes in `seo.description`) still describes its item.
+        description: page.description ?? page.meta.seo.description,
         // Encode like the sitemap does: a route with spaces or non-ASCII
         // must still yield a valid <link>/<guid> URL after XML decoding.
         link: encodeURI(`${base}${mountBasePath(deployBase, page.route)}`),