blume 2.2.0 → 2.2.1

package/src/components/layout/SiteFooter.astro

@@ -1,8 +1,8 @@
 ---
 // The site footer, below the content on every page: one row, as tall as the
-// header, with `footer.links` on one side and the social profile icons on the
-// other. The site's repository (`github`, unless `navigation.repo` hides it)
-// is the first icon; the footer is the only place it's linked. With `consent` configured the links end with the
+// header, with `footer.links` on one side, the social profile icons on the
+// other, and `footer.copyright` centered between them. The site's repository
+// (`github`, unless `navigation.repo` hides it) is the first icon; the footer is the only place it's linked. With `consent` configured the links end with the
 // Cookie settings link, which reopens the reader's consent choices. Renders
 // nothing when there's none of these; a `components.ts` `Footer` replaces it.
 import data from "blume:data";
@@ -12,6 +12,7 @@ import type { Navigation } from "../../core/types.ts";
 import { EN_UI } from "../../core/i18n-ui.ts";
 import type { UIStrings } from "../../core/i18n-ui.ts";
 import { routeSetFor } from "../../core/locale-links.ts";
+import { resolveLocalizable } from "../../core/localizable.ts";
 import { newTabAttrs } from "../../core/new-tab.ts";
 import Icon from "../Icon.astro";
 import { withBase } from "../islands/base-path.ts";
@@ -21,8 +22,9 @@ import { footerSocialLinks } from "./footer-socials.ts";
 interface Props {
   footer?: BlumeDataConfig["footer"];
   /**
-   * Active locale of the page: labels written as per-locale maps show its
-   * entry, and internal links move into it (see `footer-links.ts`).
+   * Active locale of the page: the copyright and labels written as
+   * per-locale maps show its entry, and internal links move into it (see
+   * `footer-links.ts`).
    */
   locale?: string;
   /** The page's navigation: its `repoUrl` is the repository link. */
@@ -40,6 +42,14 @@ const socials = footerSocialLinks(
     ? { href: repoUrl, label: { ...EN_UI.nav, ...ui?.nav }.githubRepository }
     : null
 );
+const copyright =
+  footer?.copyright === undefined
+    ? null
+    : resolveLocalizable(
+        footer.copyright,
+        locale,
+        data.config.i18n?.defaultLocale
+      );
 const links = footerLinks(footer?.links ?? [], {
   basePath: data.config.basePath,
   i18n: data.config.i18n,
@@ -58,9 +68,17 @@ const hasLinks = links.length > 0 || consentSettings !== null;
 ---
 
 {
-  (hasLinks || socials.length > 0) && (
+  (copyright !== null || hasLinks || socials.length > 0) && (
     <footer class="border-border border-t px-4 md:px-6" data-blume-footer>
-      <div class="flex min-h-16 flex-wrap items-center justify-between gap-x-6 gap-y-3 py-3">
+      {/* With a copyright, three columns from `md`, the outer two sharing
+          what it leaves so it sits at the true center; without one, the
+          links keep the row's full width. Narrower, the row wraps. */}
+      <div
+        class:list={[
+          "flex min-h-16 flex-wrap items-center gap-x-6 gap-y-3 py-3",
+          copyright !== null && "md:grid md:grid-cols-[1fr_auto_1fr]",
+        ]}
+      >
         {hasLinks && (
           <ul class="flex flex-wrap items-center gap-x-5 gap-y-2 text-sm">
             {links.map((link) => (
@@ -87,10 +105,15 @@ const hasLinks = links.length > 0 || consentSettings !== null;
             )}
           </ul>
         )}
+        {copyright !== null && (
+          <p class="text-muted-foreground text-sm md:col-start-2">
+            {copyright}
+          </p>
+        )}
         {/* Pulled out by the buttons' padding, so the glyphs line up with the
             footer's edge, and pushed to the far side even with no links. */}
         {socials.length > 0 && (
-          <ul class="-me-[9px] -my-[9px] ms-auto flex flex-wrap items-center gap-1">
+          <ul class="-me-[9px] -my-[9px] ms-auto flex flex-wrap items-center gap-1 md:col-start-3">
             {socials.map((social) => (
               <li>
                 <a

package/src/core/config-input.ts

@@ -22,6 +22,8 @@ import type { FontSlug } from "../theme/fonts.ts";
 import type { FooterSocial } from "./footer.ts";
 import type {
   blumeConfigSchema,
+  McpClient,
+  McpCustomClient,
   OpenInChatProvider,
   SidebarDisplay,
   SidebarItemConfig,
@@ -147,9 +149,15 @@ export interface FooterLink {
 
 /**
  * The site footer, below the content on every page: a row of links on one
- * side, and social profile icons on the other.
+ * side, social profile icons on the other, and a copyright line centered
+ * between them.
  */
 export interface FooterConfig {
+  /**
+   * A line of plain text centered between the links and the icons, like
+   * `© 2026 Acme, Inc.`, or a map of locale code to text.
+   */
+  copyright?: LocalizableLabel;
   /** Links in one row, left to right. */
   links?: FooterLink[];
   /**
@@ -719,6 +727,32 @@ export interface LlmsTxtConfig {
 
 /** Expose the docs as an MCP server for connecting agents. */
 export interface McpConfig {
+  /**
+   * The clients the "Connect to MCP" page action installs the server into,
+   * beside its "Copy server URL" row. Defaults to `true` (every built-in
+   * client). Set `false` to list none, or list built-in keys and your own
+   * clients, in order. A custom client's `command` is copied with `{name}`
+   * (the server name as an id) and `{url}` (the server's URL) filled in; its
+   * `label` localizes like a header link's, and `icon` defaults to `terminal`.
+   *
+   * ```ts
+   * agents: {
+   *   mcp: {
+   *     enabled: true,
+   *     clients: [
+   *       "claude-code",
+   *       {
+   *         label: "Copy Copilot CLI command",
+   *         command: "copilot mcp add --transport http {name} {url}",
+   *         icon: "terminal",
+   *       },
+   *       "vscode",
+   *     ],
+   *   },
+   * }
+   * ```
+   */
+  clients?: boolean | (McpClient | McpCustomClient)[];
   /** Turn the MCP server on. Defaults to `false`. */
   enabled?: boolean;
   /** Optional system hint passed to connecting agents. */
@@ -1567,8 +1601,8 @@ export interface BlumeConfig {
    */
   feedback?: boolean | FeedbackConfig;
   /**
-   * The site footer: social profile icons and up to four link columns. Unset,
-   * the site has no footer.
+   * The site footer: a copyright line, a row of links, and social profile
+   * icons. Unset, the site has no footer.
    */
   footer?: FooterConfig;
   /** Opt-in custom frontmatter keys, validated by schemas you supply. */
@@ -1597,7 +1631,7 @@ export interface BlumeConfig {
    * Limit how often one reader (by IP address) can call the server routes —
    * the assistant, the API playground proxy, server-side search — with an
    * adapter from `blume/ratelimit`: `memory()` (the default, 30 requests per
-   * 10 minutes), `upstash()`, or `cloudflare()`. `false` turns it off.
+   * 10 minutes), `upstash()`, `cloudflare()`, or `unkey()`. `false` turns it off.
    */
   rateLimit?: false | RateLimitAdapter;
   /** React island behavior (compiler auto-memoization). */

package/src/core/data.ts

@@ -187,7 +187,7 @@ export interface BlumeDataConfig {
   feedback: boolean;
   /** Whether the rating asks for a written comment after it (`feedback.comments`). */
   feedbackComments: boolean;
-  /** `footer`: social profile icons and link columns, or `null` when unset. */
+  /** `footer`: the copyright line, links, and social profile icons, or `null` when unset. */
   footer: ResolvedConfig["footer"] | null;
   /**
    * Repo coordinates for content components that address the API or build
@@ -206,8 +206,15 @@ export interface BlumeDataConfig {
   /** `markdown.imageZoom`: click-to-zoom content images. */
   imageZoom: boolean;
   logo: BlumeLogo | null;
-  /** Hosted MCP server, or `null` when MCP is off. */
-  mcp: { name: string; route: string } | null;
+  /**
+   * Hosted MCP server, or `null` when MCP is off, with the clients its
+   * "Connect to MCP" page action lists (`agents.mcp.clients`), in order.
+   */
+  mcp: {
+    clients: ResolvedConfig["agents"]["mcp"]["clients"];
+    name: string;
+    route: string;
+  } | null;
   /** `seo.metatags`: the site's own tags for every page's head, or `null`. */
   metatags: Record<string, string> | null;
   /**

package/src/core/mcp-clients.ts

@@ -0,0 +1,87 @@
+import { resolveLocalizable } from "./localizable.ts";
+import type { LocalizableLabel } from "./schema.ts";
+
+/**
+ * Clients the "Connect to MCP" page action knows how to install the server
+ * into, in display order. Shared by the config schema (`agents.mcp.clients`
+ * entries validate against this list) and the PageActions menu (which renders
+ * the full list when the config is `true`). Lives outside `schema.ts` so the
+ * component can import the list without pulling the whole config schema into
+ * the layout module graph.
+ */
+export const mcpClients = ["claude-code", "codex", "cursor", "vscode"] as const;
+
+export type McpClient = (typeof mcpClients)[number];
+
+/** A client Blume doesn't ship: a menu row that copies its `command`. */
+export interface McpCustomClient {
+  /**
+   * Command the row copies, with `{name}` (the server name as an id, like
+   * `acme-docs`) and `{url}` (the server's absolute URL) filled in.
+   */
+  command: string;
+  /** Icon beside the label: a Lucide name, inline SVG, or image. Defaults to `terminal`. */
+  icon?: string;
+  /** Row label, optionally per locale (`{ en: "…", de: "…" }`). */
+  label: LocalizableLabel;
+}
+
+export type McpClientEntry = McpClient | McpCustomClient;
+
+/** A menu entry as a page renders it: a custom label resolved to its locale. */
+export type McpMenuEntry =
+  | McpClient
+  | (Omit<McpCustomClient, "label"> & { label: string });
+
+/** Whether a `clients` entry names a built-in client rather than a custom one. */
+export const isBuiltInMcpClient = (
+  client: McpClientEntry | McpMenuEntry
+): client is McpClient => typeof client === "string";
+
+/** Resolve the custom clients' labels for one page's locale. */
+export const mcpMenuEntries = (
+  clients: readonly McpClientEntry[],
+  locale?: string,
+  defaultLocale?: string
+): McpMenuEntry[] =>
+  clients.map((client) =>
+    isBuiltInMcpClient(client)
+      ? client
+      : {
+          ...client,
+          label: resolveLocalizable(client.label, locale, defaultLocale),
+        }
+  );
+
+/** Whether a row opens an install link rather than copying a command. */
+const opensLink = (client: McpMenuEntry): boolean =>
+  client === "cursor" || client === "vscode";
+
+/**
+ * The menu's rows after "Copy server URL", each with whether a rule goes
+ * above it: wherever the list switches between commands to copy and install
+ * links ("Copy server URL" copies too), so the default menu keeps its one
+ * rule before Cursor.
+ */
+export const mcpMenuRows = (
+  entries: readonly McpMenuEntry[]
+): { client: McpMenuEntry; rule: boolean }[] =>
+  entries.map((client, index) => {
+    const previous = entries[index - 1];
+    return {
+      client,
+      rule:
+        opensLink(client) !== (previous !== undefined && opensLink(previous)),
+    };
+  });
+
+/** Fill a custom client's command for the server it installs. */
+export const mcpClientCommand = (
+  command: string,
+  server: { name: string; url: string }
+): string =>
+  // Replacer functions, not strings: a URL may contain `$`, which a string
+  // replacement would interpret as a substitution pattern.
+  command
+    .replaceAll("{name}", () => server.name)
+    .replaceAll("{url}", () => server.url);

package/src/core/nav-diagnostics.ts

@@ -1,6 +1,9 @@
 import { isAssetIcon } from "../theme/icon-kind.ts";
 import { hasIcon } from "../theme/icons.ts";
 import { isInternalPath } from "./base-path.ts";
+import { resolveLocalizable } from "./localizable.ts";
+import { isBuiltInMcpClient } from "./mcp-clients.ts";
+import type { McpClientEntry } from "./mcp-clients.ts";
 import { isPageRef, normalizeRef } from "./navigation.ts";
 import type { SidebarItemConfig } from "./schema.ts";
 import type { Diagnostic, NavNode, Navigation, PageRecord } from "./types.ts";
@@ -100,6 +103,28 @@ export const validateSearchPopularIcons = (
   return unknownIconDiagnostics(icons, ICON_FORMAT_HINT);
 };
 
+/**
+ * Warn about unknown icons on custom "Connect to MCP" clients
+ * (`agents.mcp.clients`), which live outside the navigation model too. A
+ * per-locale label is named in the default locale.
+ */
+export const validateMcpClientIcons = (
+  clients: readonly McpClientEntry[],
+  defaultLocale?: string
+): Diagnostic[] => {
+  const icons = clients.flatMap((client) =>
+    !isBuiltInMcpClient(client) && client.icon
+      ? [
+          {
+            icon: client.icon,
+            where: `MCP client "${resolveLocalizable(client.label, defaultLocale, defaultLocale)}"`,
+          },
+        ]
+      : []
+  );
+  return unknownIconDiagnostics(icons, ICON_FORMAT_HINT);
+};
+
 /** Whether an internal path resolves to a page or a section that has pages. */
 const resolvesToPages = (routes: Set<string>, path: string): boolean =>
   routes.has(path) || [...routes].some((route) => route.startsWith(`${path}/`));

package/src/core/schema.ts

@@ -43,6 +43,7 @@ import { isExternalUrl, normalizeBasePath } from "./base-path.ts";
 import { FOOTER_SOCIALS } from "./footer.ts";
 import { PUBLIC_HOST_URL } from "./github.ts";
 import { uiLocaleOverridesSchema } from "./i18n-ui.ts";
+import { isBuiltInMcpClient, mcpClients } from "./mcp-clients.ts";
 import { openInChatProviders } from "./open-in-chat.ts";
 import { PAGE_MODES } from "./page-modes.ts";
 import { redirectPatternError } from "./redirect-patterns.ts";
@@ -487,10 +488,13 @@ const apiConfigSchema = z.strictObject({
 });
 
 /**
- * The site footer: a row of links, and social profile icons. Unset, the site
- * has no footer (a `components.ts` `Footer` still renders).
+ * The site footer: a copyright line, a row of links, and social profile
+ * icons. Unset, the site has no footer (a `components.ts` `Footer` still
+ * renders).
  */
 const footerConfigSchema = z.strictObject({
+  /** A line of plain text between the links and the icons (`© 2026 Acme, Inc.`). */
+  copyright: localizableLabelSchema.optional(),
   /** Links in one row, in the order written. */
   links: z
     .array(z.strictObject({ href: z.string(), label: localizableLabelSchema }))
@@ -891,7 +895,91 @@ const publicJwkSchema = z
     }
   });
 
+// The label is the row button's only accessible name (its icon is
+// decorative), so unlike a header link's it can't be blank in any locale.
+const mcpClientLabelSchema = z.union(
+  [
+    z.string().trim().min(1),
+    z
+      .record(z.string(), z.string().trim().min(1))
+      .refine((value) => Object.keys(value).length > 0, {
+        message: "Provide at least one locale's label.",
+      }),
+  ],
+  { error: "Expected a label, or a map of locale code to label" }
+);
+
+// A "Connect to MCP" row for a client Blume doesn't ship: its `command` is
+// copied with `{name}` and `{url}` filled in.
+const mcpCustomClientSchema = z.strictObject({
+  command: z.string().trim().min(1),
+  icon: iconName.optional(),
+  label: mcpClientLabelSchema,
+});
+
+const ACCEPTED_MCP_CLIENTS = `${mcpClients.map((key) => `"${key}"`).join(", ")}, or a custom client { label, command, icon? }`;
+
+/** A union's issue: every member failed, each with issues of its own. */
+const isUnionIssue = (
+  issue: z.core.$ZodIssue
+): issue is z.core.$ZodIssueInvalidUnion => issue.code === "invalid_union";
+
+// A bad entry fails the list member of `clients`, which zod reports as a bare
+// "Invalid input" on the whole list; that union issue is all this map sees.
+// The entries' issues ride along in `errors`. The culprit is an entry that
+// matches neither a built-in key nor a custom client, which fails as a union
+// at its index (a blank field or an unknown key elsewhere doesn't fail the
+// list on its own). Name that entry, and for a custom client its bad field.
+const mcpClientsError = (issue: z.core.$ZodRawIssue): string => {
+  const entryIssue = (issue.code === "invalid_union" ? issue.errors : [])
+    .flat()
+    .filter(isUnionIssue)
+    .find((nested) => Number.isInteger(nested.path[0]));
+  if (!entryIssue) {
+    return `agents.mcp.clients takes true, false, or a list whose entries are each ${ACCEPTED_MCP_CLIENTS}.`;
+  }
+  const index = Number(entryIssue.path[0]);
+  const at = `agents.mcp.clients.${String(index)}`;
+  const entry = Array.isArray(issue.input) ? issue.input[index] : null;
+  if (isString(entry)) {
+    return `${at} is "${entry}", which isn't a built-in client. Use ${ACCEPTED_MCP_CLIENTS}.`;
+  }
+  const fieldIssue = entryIssue.errors
+    .flat()
+    .find((nested) => nested.path.length > 0);
+  return fieldIssue
+    ? `${at}.${fieldIssue.path.map(String).join(".")}: ${fieldIssue.message}. A custom client is { label, command, icon? }.`
+    : `${at} isn't ${ACCEPTED_MCP_CLIENTS}.`;
+};
+
 const mcpConfigSchema = z.strictObject({
+  /**
+   * The "Connect to MCP" page action's clients. `true` (the default) lists
+   * every built-in client, `false` none (the menu keeps "Copy server URL"),
+   * and an array picks built-in clients by key and adds custom ones, in the
+   * given order. Normalized to the list so consumers read a plain array.
+   */
+  clients: z
+    .union(
+      [
+        z.boolean(),
+        z.array(z.union([z.enum(mcpClients), mcpCustomClientSchema])).refine(
+          (value) => {
+            const keys = value.filter(isBuiltInMcpClient);
+            return new Set(keys).size === keys.length;
+          },
+          { message: "agents.mcp.clients must not repeat a built-in client." }
+        ),
+      ],
+      { error: mcpClientsError }
+    )
+    .default(true)
+    .transform((value) => {
+      if (isBoolean(value)) {
+        return value ? [...mcpClients] : [];
+      }
+      return value;
+    }),
   enabled: z.boolean().default(false),
   /** Optional system hint passed to connecting agents. */
   instructions: z.string().optional(),
@@ -1182,6 +1270,8 @@ export type AssistantConfig = NonNullable<
 >;
 export { openInChatProviders } from "./open-in-chat.ts";
 export type { OpenInChatProvider } from "./open-in-chat.ts";
+export { mcpClients } from "./mcp-clients.ts";
+export type { McpClient, McpCustomClient } from "./mcp-clients.ts";
 
 // Reader-facing "Export" page action (PDF via print, EPUB via client-side
 // generation). Off by default. Accepts a shorthand boolean to toggle both
@@ -2271,7 +2361,7 @@ export const blumeConfigSchema = z
       ctx.addIssue({
         code: z.ZodIssueCode.custom,
         message:
-          'rateLimit: cloudflare() counts with a Workers binding, so it needs `deployment: cloudflare()` from "blume/deploy". On another host, use upstash() or memory() from "blume/ratelimit".',
+          'rateLimit: cloudflare() counts with a Workers binding, so it needs `deployment: cloudflare()` from "blume/deploy". On another host, use upstash(), unkey(), or memory() from "blume/ratelimit".',
         path: ["rateLimit"],
       });
     }

package/src/ratelimit/index.ts

@@ -28,3 +28,5 @@ export type { MemoryAdapter, RateLimitOptions } from "./memory.ts";
 export type { RateLimitAdapter } from "./schema.ts";
 export { upstash } from "./upstash.ts";
 export type { UpstashAdapter, UpstashOptions } from "./upstash.ts";
+export { unkey } from "./unkey.ts";
+export type { UnkeyAdapter, UnkeyOptions } from "./unkey.ts";

package/src/ratelimit/memory.ts

@@ -35,7 +35,7 @@ export const memoryAdapterSchema = adapterDescriptorSchema(
  * platform that runs many short-lived instances (Vercel, Netlify,
  * Cloudflare) each instance keeps its own, so it stops a burst from one
  * reader rather than enforcing the limit exactly. For that, share the count
- * with `upstash()` or `cloudflare()`.
+ * with `upstash()`, `cloudflare()`, or `unkey()`.
  */
 export const memory = (options: RateLimitOptions = {}): MemoryAdapter => ({
   kind: "memory",

package/src/ratelimit/runtime.ts

@@ -11,11 +11,14 @@
  * the shared store fails to count (logged, not blocked). A shared store
  * without its secrets or binding falls back to counting in memory.
  */
+import { z } from "zod";
+
 import { clientAddressOf } from "../core/client-address.ts";
 import type { ClientContext } from "../core/client-address.ts";
 import { RATE_LIMIT_BINDING } from "./cloudflare.ts";
 import { DEFAULT_REQUESTS, DEFAULT_WINDOW } from "./memory.ts";
 import type { RateLimitAdapter } from "./schema.ts";
+import { UNKEY_MAX_WINDOW, UNKEY_NAMESPACE, unkeySecrets } from "./unkey.ts";
 import { upstashSecrets } from "./upstash.ts";
 
 /** What a limiter says about one request. */
@@ -152,6 +155,68 @@ export const upstashLimiter = (
   };
 };
 
+/** Unkey's rate limit endpoint. */
+const UNKEY_LIMIT_URL = "https://api.unkey.com/v2/ratelimit.limit";
+
+/**
+ * How long Unkey gets to count a request, in milliseconds, before the
+ * request is let through without it.
+ */
+export const UNKEY_TIMEOUT = 2000;
+
+/** The part of Unkey's reply the limiter reads. */
+const unkeyReplySchema = z.object({
+  data: z.object({
+    overrideId: z.string().optional(),
+    reset: z.number(),
+    success: z.boolean(),
+  }),
+});
+
+/**
+ * Count with Unkey's rate limit API. Unkey takes identifiers of letters,
+ * digits, and `_.:/-`, so anything else in the key (an IPv6 host's brackets,
+ * an address's `%` zone) becomes `_`. Its `reset` is a timestamp on Unkey's
+ * clock, which this server's may not match, so `retryAfter` is kept between
+ * one second and the window: the configured one, or Unkey's longest when an
+ * override set in Unkey replaced it.
+ */
+export const unkeyLimiter =
+  (
+    requests: number,
+    window: number,
+    namespace: string,
+    rootKey: string,
+    { fetch: fetchImpl = fetch, now = Date.now }: LimiterRuntime = {}
+  ): Limiter =>
+  async (key) => {
+    const response = await fetchImpl(UNKEY_LIMIT_URL, {
+      body: JSON.stringify({
+        duration: window * 1000,
+        identifier: key.replaceAll(/[^\w.:/-]/gu, "_"),
+        limit: requests,
+        namespace,
+      }),
+      headers: {
+        authorization: `Bearer ${rootKey}`,
+        "content-type": "application/json",
+      },
+      method: "POST",
+      signal: AbortSignal.timeout(UNKEY_TIMEOUT),
+    });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new Error(`Unkey answered ${response.status}.`);
+    }
+    const { data } = unkeyReplySchema.parse(await response.json());
+    const seconds = Math.ceil((data.reset - now()) / 1000);
+    const longest = data.overrideId ? UNKEY_MAX_WINDOW : window;
+    return {
+      allowed: data.success,
+      retryAfter: Math.min(longest, Math.max(1, seconds)),
+    };
+  };
+
 /** Count with a Workers rate limiting binding. */
 export const bindingLimiter =
   (binding: RateLimitBinding, window: number): Limiter =>
@@ -185,6 +250,22 @@ export const createLimiter = (
     return null;
   }
   const { requests, window } = limitOf(adapter);
+  if (adapter.kind === "unkey") {
+    const [secret] = unkeySecrets(adapter.options);
+    const rootKey = runtime.secret?.(secret);
+    if (rootKey) {
+      return unkeyLimiter(
+        requests,
+        window,
+        adapter.options.namespace ?? UNKEY_NAMESPACE,
+        rootKey,
+        runtime
+      );
+    }
+    console.warn(
+      `Rate limiting counts in memory: set ${secret} to share the count through Unkey.`
+    );
+  }
   if (adapter.kind === "cloudflare") {
     if (runtime.binding) {
       return bindingLimiter(runtime.binding, window);

package/src/ratelimit/schema.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 
 import { cloudflareRateLimitAdapterSchema } from "./cloudflare.ts";
 import { memory, memoryAdapterSchema } from "./memory.ts";
+import { unkeyAdapterSchema } from "./unkey.ts";
 import { upstashAdapterSchema } from "./upstash.ts";
 
 const ADAPTER_HINT =
@@ -12,6 +13,7 @@ export const rateLimitAdapterSchema = z.discriminatedUnion("kind", [
   cloudflareRateLimitAdapterSchema,
   memoryAdapterSchema,
   upstashAdapterSchema,
+  unkeyAdapterSchema,
 ]);
 
 export type RateLimitAdapter = z.output<typeof rateLimitAdapterSchema>;

package/src/ratelimit/unkey.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import { adapterDescriptorSchema } from "../core/adapter.ts";
+import { rateLimitOptionsSchema } from "./memory.ts";
+import type { RateLimitOptions } from "./memory.ts";
+
+/** The env var holding the Unkey root key, unless set. */
+const UNKEY_ROOT_KEY_ENV = "UNKEY_ROOT_KEY";
+
+/** The Unkey rate limit namespace the count is kept in, unless set. */
+export const UNKEY_NAMESPACE = "docs";
+
+/** The longest window Unkey takes, in seconds (30 days). */
+export const UNKEY_MAX_WINDOW = 2_592_000;
+
+/** Options for {@link unkey}. */
+export interface UnkeyOptions extends RateLimitOptions {
+  /**
+   * The Unkey rate limit namespace, up to 512 characters. Defaults to `docs`;
+   * Unkey creates it on the first request.
+   */
+  namespace?: string;
+  /** Name of the env var holding the root key. Defaults to `UNKEY_ROOT_KEY`. */
+  rootKeyEnv?: string;
+  /** The window, in seconds: Unkey takes up to 30 days. */
+  window?: number;
+}
+
+export const unkeyOptionsSchema = rateLimitOptionsSchema.extend({
+  namespace: z.string().min(1).max(512).optional(),
+  rootKeyEnv: z.string().min(1).optional(),
+  window: z.number().int().positive().max(UNKEY_MAX_WINDOW).optional(),
+});
+
+export type UnkeyAdapter = AdapterDescriptor<"unkey", UnkeyOptions>;
+
+export const unkeyAdapterSchema = adapterDescriptorSchema(
+  "unkey",
+  unkeyOptionsSchema
+);
+
+/** The env var the root key is read from. */
+export const unkeySecrets = (options: UnkeyOptions): [string] => [
+  options.rootKeyEnv ?? UNKEY_ROOT_KEY_ENV,
+];
+
+/**
+ * Counts with Unkey's rate limiting, which every instance on every host
+ * shares. Unkey counts in each region and shares the counts between them
+ * within moments, so a short burst split across regions can pass more than
+ * the limit. It talks to Unkey's REST API, so there is nothing to install;
+ * the root key comes from `UNKEY_ROOT_KEY`, or the env var `rootKeyEnv`
+ * names.
+ */
+export const unkey = (options: UnkeyOptions = {}): UnkeyAdapter => ({
+  kind: "unkey",
+  options,
+  requiredSecrets: unkeySecrets(options),
+  runtimeDeps: [],
+});

package/src/registry/registry.ts

@@ -264,7 +264,7 @@ export const registry: RegistryItem[] = [
   }),
   layoutComponent({
     description:
-      "The site footer: a row of links, social icons, the theme toggle, and the Cookie settings link.",
+      "The site footer: a copyright line, a row of links, social icons, and the Cookie settings link.",
     file: "SiteFooter.astro",
     name: "footer",
     slot: "Footer",