blume 2.0.3 → 2.1.0

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

@@ -5,6 +5,7 @@ export const zh: UIStringsOverride = {
   actions: {
     addToCursor: "添加到 Cursor",
     addToVscode: "添加到 VS Code",
+    askAboutCode: "询问这段代码",
     connectMcp: "连接到 MCP",
     copied: "已复制！",
     copyClaudeCode: "复制 Claude Code 命令",
@@ -30,11 +31,18 @@ export const zh: UIStringsOverride = {
     copy: "复制对话",
     empty: "就文档提出问题。",
     error: "抱歉，出了点问题。",
+    explainCode: "解释这段代码。",
     label: "提出问题",
+    open: "打开助手",
     placeholder: "提出问题…",
+    rateLimited: "你提的问题太多了，请几分钟后再试。",
+    removeCode: "移除代码",
     send: "发送",
+    support: "联系支持团队",
+    supportSubject: "来自文档的问题",
     tip: "提示：可通过以下快捷键打开和关闭聊天",
     title: "助手",
+    verifyFailed: "无法确认你是真人，请重试。",
     you: "你",
   },
   banner: { dismiss: "关闭公告" },
@@ -42,6 +50,14 @@ export const zh: UIStringsOverride = {
     description: "产品更新与版本说明。",
     title: "更新日志",
   },
+  consent: {
+    accept: "接受",
+    decline: "拒绝",
+    label: "Cookie 同意",
+    message: "我们希望使用 Cookie 来了解本文档的使用情况。",
+    policy: "隐私政策",
+    settings: "Cookie 设置",
+  },
   content: {
     code: "代码",
     copyColor: "复制颜色 {name} {value}",
@@ -52,6 +68,8 @@ export const zh: UIStringsOverride = {
     preview: "预览",
     prop: "属性",
     selectTab: "选择标签页",
+    selectView: "选择视图",
+    showLess: "显示更少",
     showMore: "显示更多",
     stars: "星标",
     tab: "标签页 {n}",
@@ -59,12 +77,36 @@ export const zh: UIStringsOverride = {
     update: "更新",
   },
   feedback: {
+    comment: "告诉我们更多（选填）",
     no: "没有帮助",
     question: "这个页面有帮助吗？",
+    send: "发送",
     thanks: "感谢你的反馈！",
     yes: "有帮助",
   },
   languageSwitcher: { label: "语言", untranslated: "未翻译" },
+  narration: {
+    cueDanger: "危险。",
+    cueInfo: "信息。",
+    cueNote: "备注。",
+    cueSection: "可展开部分。",
+    cueStep: "第 {n} 步。",
+    cueSuccess: "成功。",
+    cueTab: "{title} 标签页。",
+    cueTip: "提示。",
+    cueWarning: "警告。",
+    error: "无法加载朗读音频。",
+    follow: "跟随朗读",
+    label: "收听此页面",
+    minutes: "{n} 分钟",
+    next: "下一句",
+    pause: "暂停",
+    play: "播放",
+    previous: "上一句",
+    progress: "朗读进度",
+    speed: "播放速度",
+    stop: "停止收听",
+  },
   nav: {
     back: "返回",
     breadcrumb: "面包屑导航",
@@ -89,6 +131,7 @@ export const zh: UIStringsOverride = {
     next: "下一页",
     pagination: "分页",
     previous: "上一页",
+    related: "相关页面",
     skipToContent: "跳到内容",
   },
   search: {

package/src/core/variables.ts

@@ -0,0 +1,103 @@
+import { nextFenceState } from "./code-fences.ts";
+import type { FenceState } from "./code-fences.ts";
+
+/**
+ * Content variables: `variables: { version: "2.1.0" }` in `blume.config.ts`
+ * makes `{{version}}` in a page read `2.1.0` wherever it appears in the body,
+ * code and links included. The syntax is Mintlify's, so migrated pages keep
+ * working.
+ *
+ * Substitution is textual, before any parsing, so a page's HTML, its search
+ * entry, its `.md` mirror, and `llms-full.txt` all agree: the MDX pipeline
+ * substitutes in a Vite transform ahead of the compiler (an MDX parser would
+ * read `{{version}}` as a JavaScript expression), the Markdown pipeline in a
+ * plugin over the parsed text, includes as their files are read, and the raw
+ * readers through {@link substituteVariables}. Only defined names are
+ * replaced; an undefined one in prose is a build error
+ * (`BLUME_UNDEFINED_VARIABLE`), and inside code it is left alone, since
+ * templating examples (`{{name}}` in a Handlebars snippet) are common there.
+ */
+
+/** The variables a site defines, name to value. */
+export type ContentVariables = Readonly<Record<string, string>>;
+
+/** A variable name: letters, digits, `_`, and `-` (Mintlify's `api-url`). */
+export const VARIABLE_NAME = /^[\w-]+$/u;
+
+/** A `{{name}}` reference, spaces inside the braces allowed. */
+const REFERENCE = /\{\{\s*(?<name>[\w-]+)\s*\}\}/gu;
+
+/** Whether a site defines any variables, so the rest can be skipped. */
+export const hasVariables = (
+  variables?: ContentVariables
+): variables is ContentVariables =>
+  variables !== undefined && Object.keys(variables).length > 0;
+
+/** `text` with every reference to a defined variable replaced by its value. */
+export const substituteVariables = (
+  text: string,
+  variables?: ContentVariables
+): string => {
+  if (!(hasVariables(variables) && text.includes("{{"))) {
+    return text;
+  }
+  return text.replaceAll(REFERENCE, (match, name: string) =>
+    Object.hasOwn(variables, name) ? (variables[name] ?? match) : match
+  );
+};
+
+// A leading front matter block: variables apply to the body, not to it.
+const FRONT_MATTER = /^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/u;
+
+/**
+ * {@link substituteVariables} over a page's raw source, leaving its front
+ * matter as written: the rendered page reads its title and description from
+ * the unsubstituted front matter, so the other surfaces must too.
+ */
+export const substituteVariablesInBody = (
+  source: string,
+  variables?: ContentVariables
+): string => {
+  const head = FRONT_MATTER.exec(source)?.[0] ?? "";
+  return head + substituteVariables(source.slice(head.length), variables);
+};
+
+/** An undefined variable referenced in prose, with its 1-based line. */
+export interface UndefinedVariable {
+  line: number;
+  name: string;
+}
+
+// A backtick code span: the same run of backticks opens and closes it.
+const CODE_SPAN = /(?<ticks>`+)[^`][\s\S]*?\k<ticks>/gu;
+
+/**
+ * The undefined variables `text` references outside code: fenced blocks and
+ * inline code spans are skipped, so a templating example never fails a
+ * build. Empty when the site defines no variables at all, so a page that
+ * shows `{{…}}` literally keeps working until the site opts in.
+ */
+export const undefinedVariables = (
+  text: string,
+  variables?: ContentVariables
+): UndefinedVariable[] => {
+  if (!(hasVariables(variables) && text.includes("{{"))) {
+    return [];
+  }
+  const found: UndefinedVariable[] = [];
+  let fence: FenceState = null;
+  for (const [index, line] of text.split("\n").entries()) {
+    const wasInFence = fence !== null;
+    fence = nextFenceState(line, fence);
+    if (wasInFence || fence !== null) {
+      continue;
+    }
+    for (const match of line.replaceAll(CODE_SPAN, "").matchAll(REFERENCE)) {
+      const name = match.groups?.name ?? "";
+      if (!Object.hasOwn(variables, name)) {
+        found.push({ line: index + 1, name });
+      }
+    }
+  }
+  return found;
+};

package/src/deploy/artifacts.ts

@@ -14,6 +14,11 @@ import { API_CATALOG_PATH, buildApiCatalog } from "../ai/api-catalog.ts";
 import { buildHomeLinkHeader } from "../ai/link-headers.ts";
 import { buildLlmsFiles } from "../ai/llms.ts";
 import { markdownRoutePaths } from "../ai/markdown.ts";
+import {
+  buildSiteSkill,
+  SKILL_MD_PATH,
+  siteSkillName,
+} from "../ai/site-skill.ts";
 import {
   AGENT_SKILLS_DIR,
   AGENT_SKILLS_INDEX_PATH,
@@ -29,6 +34,7 @@ import { normalizeBasePath } from "../core/base-path.ts";
 import { discoverPagesSync } from "../core/custom-pages.ts";
 import type { BlumeProject } from "../core/project-graph.ts";
 import type { ResolvedConfig } from "../core/schema.ts";
+import { buildNarration } from "../narration/build.ts";
 import { buildSearchIndex } from "../search/build.ts";
 import { syncSearchProvider } from "../search/sync/index.ts";
 import { readsHeaderFiles } from "./adapter-output.ts";
@@ -212,7 +218,8 @@ export const emitHeaderFiles = async (
 
 /**
  * Collect the Agent Skills `agents.skills` publishes, once per build, so both the
- * skills surface and llms.txt (which lists them) read the same set. Empty
+ * skills surface and llms.txt (which lists them) read the same set (the
+ * generated site skill joins them in {@link publishedSkills}). Empty
  * when the feature is off, the directory is missing, nothing in it is
  * publishable (each with a warning), or a user-shipped
  * `public/.well-known/agent-skills/index.json` already owns the surface.
@@ -248,6 +255,57 @@ const collectConfiguredSkills = async (
   return skills;
 };
 
+/**
+ * Every skill the build publishes: the `agents.skills` ones, plus the
+ * generated site skill unless one of those shares its name (the hand-written
+ * one wins) or a user-shipped index owns the surface.
+ */
+const publishedSkills = async (
+  project: BlumeProject,
+  distDir: string,
+  surface: { mcp: boolean; userIndex: boolean },
+  logger: ArtifactLogger
+): Promise<SkillArtifact[]> => {
+  const configured = await collectConfiguredSkills(project, distDir, logger);
+  // The skill lists the MCP server only when the build serves it.
+  const site = surface.userIndex
+    ? null
+    : buildSiteSkill({
+        ...project,
+        config: advertisedConfig(project.config, {
+          mcp: surface.mcp,
+          skills: true,
+        }),
+      });
+  return site && !configured.some((skill) => skill.name === site.name)
+    ? [site, ...configured]
+    : configured;
+};
+
+/**
+ * Serve the site skill at `/skill.md` too, the path agents try first: the
+ * generated one, or a same-named hand-written skill that is a lone
+ * `SKILL.md` (an archive's relative references need its other files). A
+ * `public/skill.md` wins.
+ */
+const emitSkillMd = async (
+  project: BlumeProject,
+  distDir: string,
+  skills: readonly SkillArtifact[],
+  logger: ArtifactLogger
+): Promise<void> => {
+  const target = join(distDir, SKILL_MD_PATH.slice(1));
+  const name = siteSkillName(project);
+  const skill = skills.find(
+    (candidate) => candidate.name === name && candidate.type === "skill-md"
+  );
+  if (!(project.config.agents.skillMd && skill) || existsSync(target)) {
+    return;
+  }
+  await writeFile(target, skill.content);
+  logger.info(`Generated ${SKILL_MD_PATH.slice(1)} (the "${name}" skill)`);
+};
+
 /**
  * Publish the collected Agent Skills: copy each skill artifact under
  * `.well-known/agent-skills/` and emit the discovery index. A user-shipped
@@ -382,6 +440,10 @@ export const publishBuildArtifacts = async (
     logger.info(`Indexed ${indexed} page(s) for search`);
   }
 
+  // Generated narration reads the built pages, so it runs once they exist.
+  // Nothing happens without `narration.provider`.
+  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.
   await syncSearchProvider(project, {
@@ -394,18 +456,24 @@ export const publishBuildArtifacts = async (
   const userSkillsIndex = existsSync(
     join(distDir, AGENT_SKILLS_INDEX_PATH.slice(1))
   );
-  const skills = await collectConfiguredSkills(project, distDir, logger);
+  const mcp = servesMcp(
+    project,
+    project.context.pagesRoot
+      ? discoverPagesSync(project.context.pagesRoot)
+      : []
+  );
+  const skills = await publishedSkills(
+    project,
+    distDir,
+    { mcp, userIndex: userSkillsIndex },
+    logger
+  );
   // The discovery documents advertise what this build serves: no MCP server
   // when a page took its route, no skills index when nothing was published.
   const advertised: BlumeProject = {
     ...project,
     config: advertisedConfig(project.config, {
-      mcp: servesMcp(
-        project,
-        project.context.pagesRoot
-          ? discoverPagesSync(project.context.pagesRoot)
-          : []
-      ),
+      mcp,
       skills: skills.length > 0 || userSkillsIndex,
     }),
   };
@@ -444,6 +512,7 @@ export const publishBuildArtifacts = async (
 
   await emitWellKnownFiles(advertised.config, distDir, skills, logger);
   await emitAgentSkills(project, distDir, skills, logger);
+  await emitSkillMd(project, distDir, skills, logger);
 
   await emitRedirectFiles(advertised, distDir, logger);
   await emitHeaderFiles(advertised, distDir, logger);

package/src/deploy/cloudflare-negotiation.ts

@@ -85,6 +85,7 @@ import {
   OPENAPI_PATH,
 } from "../ai/api/paths.ts";
 import { normalizeBasePath, normalizePath } from "../core/base-path.ts";
+import { compileRedirects, isPatternPath } from "../core/redirect-patterns.ts";
 import { CONTENT_ASSETS_ROOT, SVG_ASSET_HEADERS } from "./headers.ts";
 import type { NotFoundVariants } from "./vercel-negotiation.ts";
 
@@ -289,12 +290,18 @@ export const buildNegotiationWorker = (
   // header, which cannot carry non-ASCII.
   const redirects = JSON.stringify(
     Object.fromEntries(
-      (options.redirects ?? []).map((redirect) => [
-        normalizePath(redirect.from),
-        [encodeURI(redirect.to), redirect.status],
-      ])
+      (options.redirects ?? [])
+        .filter((redirect) => !isPatternPath(redirect.from))
+        .map((redirect) => [
+          normalizePath(redirect.from),
+          [encodeURI(redirect.to), redirect.status],
+        ])
     )
   );
+  // Patterns (`/beta/:slug*`) are tried in order after the exact paths.
+  const patternRedirects = JSON.stringify(
+    compileRedirects(options.redirects ?? [])
+  );
   return `// Generated by Blume. Do not edit; this file is recreated on each build.
 //
 // Request-time \`Accept: text/markdown\` negotiation for a Cloudflare server
@@ -319,6 +326,9 @@ const ASSETS_BINDING = ${binding};
 const HOME_LINK_HEADER = ${homeLinkHeader};
 const HOME_TOKENS = ${homeTokens};
 const REDIRECTS = ${redirects};
+const PATTERN_REDIRECTS = ${patternRedirects}.map(
+  ([source, location, status]) => [new RegExp(source, "u"), location, status]
+);
 const NOT_FOUND = ${notFound};
 const SVG_ASSET_HEADERS = ${JSON.stringify(SVG_ASSET_HEADERS)};
 
@@ -335,11 +345,31 @@ const isSvgAsset = (pathname) => {
 // reads — a worker-first route never reaches it. Answering from this baked-in
 // copy keeps the exact configured status; delegating instead would let Astro's
 // SSR handler default a GET to a permanent 301.
+// An exact path is looked up first, then each pattern is tried in order, its
+// Location template filled with the captures, encoded so a capture can't grow
+// a query or fragment.
 const redirectFor = (pathname) => {
   const trimmed =
     pathname !== "/" && pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
   const path = safeDecode(trimmed);
-  return Object.hasOwn(REDIRECTS, path) ? REDIRECTS[path] : null;
+  if (Object.hasOwn(REDIRECTS, path)) {
+    return REDIRECTS[path];
+  }
+  const decoded = safeDecode(pathname);
+  for (const [pattern, location, status] of PATTERN_REDIRECTS) {
+    const match = pattern.exec(decoded);
+    if (match) {
+      return [
+        location.replace(/\\$(\\d+)/gu, (_reference, index) =>
+          encodeURI(match[Number(index)] ?? "")
+            .replaceAll("?", "%3F")
+            .replaceAll("#", "%23")
+        ),
+        status,
+      ];
+    }
+  }
+  return null;
 };
 
 // The request path with the deployment base removed: the whole path on a

package/src/deploy/headers.ts

@@ -4,6 +4,7 @@ import {
   API_CATALOG_TYPE,
   hasApiCatalog,
 } from "../ai/api-catalog.ts";
+import { servesSkillsIndex } from "../ai/skills.ts";
 import {
   SIGNATURES_DIRECTORY_PATH,
   SIGNATURES_DIRECTORY_TYPE,
@@ -128,7 +129,7 @@ export const headerRules = (
   }
   // Published skills live at the deployment base, and the RFC wants their
   // archives served as application/gzip explicitly.
-  if (config.agents.skills) {
+  if (servesSkillsIndex(config)) {
     rules.push(
       {
         name: "Content-Type",

package/src/deploy/node-headers.ts

@@ -15,6 +15,8 @@ import {
 } from "../ai/web-bot-auth.ts";
 import { normalizeBasePath, normalizePath } from "../core/base-path.ts";
 import type { BlumeProject } from "../core/project-graph.ts";
+import { compileRedirects, isPatternPath } from "../core/redirect-patterns.ts";
+import type { CompiledRedirect } from "../core/redirect-patterns.ts";
 import type { ResolvedConfig } from "../core/schema.ts";
 import { SVG_ASSET_HEADERS, svgAssetPath } from "./headers.ts";
 import { distDir } from "./platforms/paths.ts";
@@ -106,11 +108,12 @@ const patternRules = (
 export type NodeRedirects = Record<string, [string, number]>;
 
 /**
- * The configured redirects, based the way the host matches them (see
+ * The configured exact redirects, based the way the host matches them (see
  * `platformRedirects`) and keyed for the wrapper's lookup, the `Location`
  * percent-encoded as Astro sends it. A redirect at a content route's own path
  * is left out: the prerendered page owns that URL, and the static handler
- * serves it before Astro's redirect ever could.
+ * serves it before Astro's redirect ever could. Patterns are compiled apart
+ * ({@link nodePatternRedirects}).
  */
 export const nodeRedirects = (project: BlumeProject): NodeRedirects => {
   const { config } = project;
@@ -125,7 +128,13 @@ export const nodeRedirects = (project: BlumeProject): NodeRedirects => {
   );
   return Object.fromEntries(
     platformRedirects(project)
-      .filter((redirect) => !pages.has(normalizePath(redirect.from)))
+      .filter(
+        (redirect) =>
+          !(
+            isPatternPath(redirect.from) ||
+            pages.has(normalizePath(redirect.from))
+          )
+      )
       .map((redirect) => [
         normalizePath(redirect.from),
         [encodeURI(redirect.to), redirect.status],
@@ -133,12 +142,27 @@ export const nodeRedirects = (project: BlumeProject): NodeRedirects => {
   );
 };
 
+/**
+ * The configured pattern redirects (`/beta/:slug*`), based the way the host
+ * matches them and compiled for the wrapper, which tries them in order after
+ * the exact ones. None can match a page: the scan rejects a pattern that
+ * does (`BLUME_REDIRECT_MATCHES_PAGE`).
+ */
+export const nodePatternRedirects = (
+  project: BlumeProject
+): CompiledRedirect[] =>
+  project.config.redirects.length === 0
+    ? []
+    : compileRedirects(platformRedirects(project));
+
 /** What the wrapper needs beyond the header rules. */
 export interface NodeEntryOptions {
   /** `deployment.base`, normalized (`""` at the root). */
   base?: string;
   /** The configured redirects, from {@link nodeRedirects}. */
   redirects?: NodeRedirects;
+  /** The configured pattern redirects, from {@link nodePatternRedirects}. */
+  patternRedirects?: CompiledRedirect[];
 }
 
 /**
@@ -177,6 +201,9 @@ const BASE = ${JSON.stringify(options.base ?? "")};
 const RULES = new Map(${JSON.stringify(exactRules(rules))});
 const PATTERNS = ${JSON.stringify(patternRules(rules))};
 const REDIRECTS = ${JSON.stringify(options.redirects ?? {})};
+const PATTERN_REDIRECTS = ${JSON.stringify(options.patternRedirects ?? [])}.map(
+  ([source, location, status]) => [new RegExp(source, "u"), location, status]
+);
 const safeDecode = (path) => {
   try {
     return decodeURIComponent(path);
@@ -210,16 +237,37 @@ const applyHeaders = (req, res) => {
     }
   }
 };
+// A pattern redirect's Location: its template, each $n filled with that
+// capture, encoded so it can't grow a query or fragment.
+const fillLocation = (location, match) =>
+  location.replace(/\\$(\\d+)/gu, (_reference, index) =>
+    encodeURI(match[Number(index)] ?? "")
+      .replaceAll("?", "%3F")
+      .replaceAll("#", "%23")
+  );
+// The configured redirect for a decoded path: an exact one, else the first
+// pattern that matches it.
+const redirectFor = (path) => {
+  const trimmed = path !== "/" && path.endsWith("/") ? path.slice(0, -1) : path;
+  if (Object.hasOwn(REDIRECTS, trimmed)) {
+    return REDIRECTS[trimmed];
+  }
+  for (const [pattern, location, status] of PATTERN_REDIRECTS) {
+    const match = pattern.exec(path);
+    if (match) {
+      return [fillLocation(location, match), status];
+    }
+  }
+  return null;
+};
 // Answer a configured redirect with its exact status; Astro's handler would
 // send a 301 (a 308 for other methods) whatever the configured one.
 const answerRedirect = (req, res) => {
-  const path = urlPath(req);
-  const trimmed = path !== "/" && path.endsWith("/") ? path.slice(0, -1) : path;
-  const key = safeDecode(trimmed);
-  if (!Object.hasOwn(REDIRECTS, key)) {
+  const redirect = redirectFor(safeDecode(urlPath(req)));
+  if (redirect === null) {
     return false;
   }
-  const [location, status] = REDIRECTS[key];
+  const [location, status] = redirect;
   res.writeHead(status, { location });
   res.end();
   return true;
@@ -291,7 +339,12 @@ export const wrapNodeEntry = async (
       : []),
   ];
   const redirects = nodeRedirects(project);
-  if (rules.length === 0 && Object.keys(redirects).length === 0) {
+  const patternRedirects = nodePatternRedirects(project);
+  if (
+    rules.length === 0 &&
+    Object.keys(redirects).length === 0 &&
+    patternRedirects.length === 0
+  ) {
     return;
   }
   const serverDir = join(distDir(project.context), "server");
@@ -311,6 +364,7 @@ export const wrapNodeEntry = async (
     entry,
     nodeEntryWrapper(rules, {
       base: normalizeBasePath(project.config.deployment.options.base),
+      patternRedirects,
       redirects,
     }),
     "utf-8"

package/src/deploy/platforms/cloudflare.ts

@@ -14,6 +14,7 @@ import {
 import { normalizeBasePath } from "../../core/base-path.ts";
 import type { BlumeProject } from "../../core/project-graph.ts";
 import type { ProjectContext } from "../../core/types.ts";
+import { withRateLimitBinding } from "../../ratelimit/wrangler.ts";
 import { CLOUDFLARE_ADAPTER_PACKAGE } from "../adapters/cloudflare.ts";
 import {
   injectWorkerNegotiation,
@@ -273,6 +274,36 @@ export const nameCloudflareWorker = async (
   );
 };
 
+/**
+ * Declare the Workers rate limiting binding `rateLimit: cloudflare()` counts
+ * with in the built Worker's config, which `wrangler deploy` reads.
+ */
+export const bindCloudflareRateLimit = async (
+  project: BlumeProject,
+  log: BuildLog
+): Promise<void> => {
+  const { rateLimit } = project.config;
+  if (rateLimit?.kind !== "cloudflare") {
+    return;
+  }
+  const wranglerPath = join(
+    distDir(project.context),
+    "server",
+    "wrangler.json"
+  );
+  const bound = existsSync(wranglerPath)
+    ? withRateLimitBinding(await readFile(wranglerPath, "utf-8"), rateLimit)
+    : null;
+  if (bound === null) {
+    log.warn(
+      "Could not declare the rate limiting binding in dist/server/wrangler.json — the routes count in memory instead."
+    );
+    return;
+  }
+  await writeFile(wranglerPath, bound, "utf-8");
+  log.success("Declared the Workers rate limiting binding");
+};
+
 /**
  * Cloudflare Workers and Pages. A server build emits the Worker into
  * `dist/server` and serves `dist/client` through the ASSETS binding, which
@@ -298,6 +329,7 @@ export const cloudflarePlatform: DeployPlatform = {
     if (!isolated) {
       await nameCloudflareWorker(project, log);
       await emitCloudflareNegotiation(project, log);
+      await bindCloudflareRateLimit(project, log);
       await emitCloudflareDeployConfig(project.context);
     }
     return true;

package/src/deploy/platforms/netlify.ts

@@ -9,7 +9,11 @@ import type { BlumeProject } from "../../core/project-graph.ts";
 import { NETLIFY_ADAPTER_PACKAGE } from "../adapters/netlify.ts";
 import { buildNetlifyConfigHeaders } from "../headers.ts";
 import type { NetlifyConfigHeaders } from "../headers.ts";
-import { buildNetlifyRedirects } from "../redirects.ts";
+import {
+  buildNetlifyRedirects,
+  netlifyPatternRedirects,
+  platformRedirects,
+} from "../redirects.ts";
 import { distDir, toSiteUrl } from "./paths.ts";
 import type { BuildLog, DeployPlatform, RedirectFile } from "./types.ts";
 
@@ -76,6 +80,33 @@ export const emitNetlifyHeaders = async (
   await writeFile(configPath, JSON.stringify(frameworks), "utf-8");
 };
 
+/**
+ * Carry the pattern redirects (`/beta/:slug*`) into a server build, as
+ * `redirects` in the Frameworks API config: Astro's `redirects` carry only
+ * the exact ones, since it can't prerender a pattern's pages, so the adapter
+ * never writes these. Netlify appends them after any rules of the user's own.
+ */
+export const emitNetlifyPatternRedirects = async (
+  project: BlumeProject
+): Promise<void> => {
+  const ours = netlifyPatternRedirects(platformRedirects(project));
+  const configPath = join(project.context.root, NETLIFY_CONFIG_FILE);
+  if (ours.length === 0 || !existsSync(configPath)) {
+    return;
+  }
+  // Only `redirects` is read; every other key rides through as parsed.
+  const frameworks: { redirects?: { from: string }[] } = JSON.parse(
+    await readFile(configPath, "utf-8")
+  );
+  // A second pass over the same build replaces its own entries.
+  const froms = new Set(ours.map((entry) => entry.from));
+  frameworks.redirects = [
+    ...(frameworks.redirects ?? []).filter((entry) => !froms.has(entry.from)),
+    ...ours,
+  ];
+  await writeFile(configPath, JSON.stringify(frameworks), "utf-8");
+};
+
 /**
  * Netlify. A server build runs on Netlify Functions from the Frameworks API
  * tree the adapter writes to `.netlify/v1`, relative to the Astro root —
@@ -106,6 +137,7 @@ export const netlifyPlatform: DeployPlatform = {
     // never surfaces it.
     if (!isolated) {
       await emitNetlifyHeaders(project, log);
+      await emitNetlifyPatternRedirects(project);
     }
     return true;
   },