blume 2.1.3 → 2.2.1

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/eject.ts

@@ -813,7 +813,6 @@ export const eject = async (
     exportEpub,
     exportPdf,
     needsReact,
-    staged: hasStaged,
   });
 
   if (config.seo.og.enabled) {

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",

package/src/search/documents.ts

@@ -29,6 +29,7 @@ import {
   MARKDOWN_BODY_FEATURES,
   MDX_BODY_FEATURES,
 } from "../markdown/features.ts";
+import { normalizeFence } from "../markdown/fence-language.ts";
 import { pageFacets } from "./facets.ts";
 
 /** A document indexed by the client-side search providers (Orama, FlexSearch). */
@@ -177,7 +178,13 @@ const collectCode = (
   if (!walk.includeCodeBlocks) {
     return;
   }
-  const title = parseCodeTitle(node.meta ?? undefined);
+  // The fence as the page renders it (`[file.ts]{2}` splits, `JSON`
+  // lowercases), so the indexed title is the one the page shows.
+  const fence = normalizeFence(node.lang, node.meta) ?? node;
+  const title = parseCodeTitle(
+    fence.meta ?? undefined,
+    fence.lang ?? undefined
+  );
   if (title) {
     out.push(title, " ");
   }
@@ -504,7 +511,8 @@ export const buildSearchDocuments = async (
       return false;
     }
     const page = pageById.get(route.id);
-    return page ? contentIndexable(page, project.config) : false;
+    const { config, graph } = project;
+    return page ? contentIndexable(page, config, graph) : false;
   });
 
   // Built once — `downlevelComponents` rebuilds its registry per call

package/src/sources/filesystem.ts

@@ -7,12 +7,37 @@ import { DEFAULT_CONTENT_GLOB, sharedSourceOptionsSchema } from "./shared.ts";
 
 /** What `include` defaults to: every Markdown/MDX file under the root. */
 export const DEFAULT_CONTENT_INCLUDE = [DEFAULT_CONTENT_GLOB];
-/** What `exclude` defaults to: underscore- and dot-prefixed paths. */
+/** What `exclude` always holds: underscore- and dot-prefixed paths. */
 export const DEFAULT_CONTENT_EXCLUDE = ["**/_*", "**/.*"];
 
+/**
+ * A source's `exclude` as the scan applies it: the defaults, plus the
+ * author's patterns. A `!pattern` entry takes that exact pattern back out, a
+ * default included, so `["!**\/_*"]` publishes `_`-prefixed files. The glob
+ * library can't negate an ignore pattern itself.
+ */
+export const resolveContentExclude = (
+  patterns: readonly string[]
+): string[] => {
+  const kept = new Set(
+    patterns.flatMap((pattern) =>
+      pattern.startsWith("!") ? [pattern.slice(1)] : []
+    )
+  );
+  return [
+    ...new Set([
+      ...DEFAULT_CONTENT_EXCLUDE,
+      ...patterns.filter((pattern) => !pattern.startsWith("!")),
+    ]),
+  ].filter((pattern) => !kept.has(pattern));
+};
+
 /** Options for {@link filesystem}. */
 export interface FilesystemOptions extends SharedSourceOptions {
-  /** Glob patterns to ignore. Defaults to `["**\/_*", "**\/.*"]`. */
+  /**
+   * Glob patterns to ignore, on top of `["**\/_*", "**\/.*"]`. A `!pattern`
+   * entry stops ignoring that pattern, a default included.
+   */
   exclude?: string[];
   /** Glob patterns to include. Defaults to `["**\/*.{md,mdx}"]`. */
   include?: string[];
@@ -21,7 +46,7 @@ export interface FilesystemOptions extends SharedSourceOptions {
 }
 
 export const filesystemOptionsSchema = sharedSourceOptionsSchema.extend({
-  exclude: z.array(z.string()).default(DEFAULT_CONTENT_EXCLUDE),
+  exclude: z.array(z.string()).default([]).transform(resolveContentExclude),
   include: z.array(z.string()).default(DEFAULT_CONTENT_INCLUDE),
   root: z.string().default("docs"),
 });

package/src/sources/mdx-remote.ts

@@ -50,27 +50,19 @@ export const mdxRemoteAdapterSchema = adapterDescriptorSchema(
   mdxRemoteOptionsSchema
 );
 
-// The hosts the source ever sends `GITHUB_TOKEN` to (the same set the fetch
-// in core/sources/mdx-remote.ts checks), so only an adapter reading from
-// GitHub declares the variable.
-const GITHUB_HOSTS = new Set(["api.github.com", "raw.githubusercontent.com"]);
-
-const readsFromGithub = (options: MdxRemoteOptions): boolean =>
-  options.github !== undefined ||
-  (options.url !== undefined &&
-    URL.canParse(options.url) &&
-    GITHUB_HOSTS.has(new URL(options.url).hostname));
-
 /**
  * Remote Markdown/MDX fetched over HTTP. Enumerate files explicitly against a
  * raw `url` base, or from a GitHub repo subtree via `github`. A private repo's
- * token comes from `GITHUB_TOKEN` — never inline it here. The adapter declares
- * the variable only when it reads from GitHub, since a `url` on any other host
- * is never sent the token.
+ * token comes from `GITHUB_TOKEN` — never inline it here. Only `github`
+ * declares the variable: it lists files through GitHub's API, whose
+ * unauthenticated rate limit a build can run into even for a public
+ * repository. A raw `url` needs no token for a public repository, so a fetch
+ * that fails for want of one names the variable instead (see
+ * core/sources/mdx-remote.ts).
  */
 export const mdxRemote = (options: MdxRemoteOptions): MdxRemoteAdapter => ({
   kind: "mdx-remote",
   options,
-  requiredSecrets: readsFromGithub(options) ? ["GITHUB_TOKEN"] : [],
+  requiredSecrets: options.github ? ["GITHUB_TOKEN"] : [],
   runtimeDeps: [],
 });

package/src/theme/color.ts

@@ -470,6 +470,20 @@ export const parseColor = (value: string): Rgba | null => {
     : null;
 };
 
+// Color syntax `parseColor` leaves unread but a browser takes: a custom
+// property, `color-mix()`, `color()`, `light-dark()`, a relative color
+// (`oklch(from var(--x) l c h)`), and the `currentcolor` keyword.
+const UNREAD_COLOR =
+  /^(?:currentcolor|(?:color|color-mix|hsla?|hwb|lab|lch|light-dark|oklab|oklch|rgba?|var)\(.*\))$/isu;
+
+/**
+ * Whether `value` is a CSS color: one `parseColor` reads, or a color function
+ * or keyword it leaves unread. Words that name no color (`deep purple`), and
+ * hex values with a wrong digit count or no `#`, are not.
+ */
+export const isCssColor = (value: string): boolean =>
+  parseColor(value) !== null || UNREAD_COLOR.test(value.trim());
+
 /** `color` painted over an opaque `backdrop`. */
 export const composite = (color: Rgba, backdrop: Rgba): Rgba => {
   const mix = (top: number, bottom: number): number =>

package/src/theme/entry.ts

@@ -63,13 +63,18 @@ const TOKEN_DEFAULTS = `:root {
   --blume-action: var(--blume-accent);
   --blume-action-foreground: var(--blume-accent-foreground);
   --blume-code-background: oklch(0.99 0 0);
-  /* Shiki notation transformers: line/word highlight, diff add/remove. */
+  /* Shiki notation transformers: line/word highlight, diff add/remove, and
+     error/warning lines. */
   --blume-code-highlight: oklch(0.55 0.16 255 / 0.1);
   --blume-code-highlight-border: oklch(0.55 0.16 255 / 0.55);
   --blume-code-add: oklch(0.72 0.16 150 / 0.16);
   --blume-code-add-border: oklch(0.52 0.15 150 / 0.7);
   --blume-code-remove: oklch(0.66 0.21 22 / 0.16);
   --blume-code-remove-border: oklch(0.55 0.2 22 / 0.7);
+  --blume-code-error: oklch(0.66 0.21 22 / 0.16);
+  --blume-code-error-border: oklch(0.55 0.2 22 / 0.7);
+  --blume-code-warning: oklch(0.8 0.16 80 / 0.2);
+  --blume-code-warning-border: oklch(0.66 0.15 70 / 0.75);
   --blume-code-word: oklch(0.55 0.16 255 / 0.16);
   --blume-code-word-border: oklch(0.55 0.16 255 / 0.5);
   --blume-radius: 0.75rem;
@@ -129,6 +134,10 @@ const TOKEN_DEFAULTS = `:root {
   --blume-code-add-border: oklch(0.72 0.16 150 / 0.7);
   --blume-code-remove: oklch(0.72 0.21 22 / 0.22);
   --blume-code-remove-border: oklch(0.7 0.2 22 / 0.7);
+  --blume-code-error: oklch(0.72 0.21 22 / 0.22);
+  --blume-code-error-border: oklch(0.7 0.2 22 / 0.7);
+  --blume-code-warning: oklch(0.82 0.16 80 / 0.18);
+  --blume-code-warning-border: oklch(0.82 0.16 80 / 0.7);
   --blume-code-word: oklch(0.7 0.14 255 / 0.22);
   --blume-code-word-border: oklch(0.7 0.14 255 / 0.55);
 }`;
@@ -866,6 +875,18 @@ pre[data-line-numbers] .line::before {
   box-shadow: inset 2px 0 0 0 var(--blume-code-remove-border);
 }
 
+/* Error and warning lines (\`// [!code error]\`, \`// [!code warning]\`) are
+   highlighted lines with a level class, tinted red and amber. */
+.line.highlighted.error {
+  background-color: var(--blume-code-error) !important;
+  box-shadow: inset 2px 0 0 0 var(--blume-code-error-border);
+}
+
+.line.highlighted.warning {
+  background-color: var(--blume-code-warning) !important;
+  box-shadow: inset 2px 0 0 0 var(--blume-code-warning-border);
+}
+
 /* Word highlight (\`// [!code word:x]\`) wraps matches in an inline span. The
    element selector keeps it ahead of the transparent token-span rule. */
 span.highlighted-word {

package/src/theme/palette.ts

@@ -1,5 +1,5 @@
 import type { ResolvedConfig } from "../core/schema.ts";
-import { composite, contrastRatio, parseColor } from "./color.ts";
+import { composite, contrastRatio, isCssColor, parseColor } from "./color.ts";
 import type { Rgba } from "./color.ts";
 
 /** Per-mode CSS colors. */
@@ -243,3 +243,76 @@ ${root}
 }
 ${dark}`;
 };
+
+/** A configured color: where the config sets it, and its value. */
+export interface ColorSetting {
+  /** The config path, e.g. `["theme", "accent", "dark"]`. */
+  path: string[];
+  /** Whether the field also takes an accent preset name (`teal`). */
+  presets: boolean;
+  value: string;
+}
+
+const MODES = ["light", "dark"] as const;
+
+/**
+ * A per-mode field's settings. Both modes holding one value (a string, which
+ * the schema copies into each) is one setting at the field itself, so a
+ * mistake is reported once, at the key that set it.
+ */
+const modeSettings = (
+  path: string[],
+  value: { dark?: string; light?: string } | undefined,
+  presets: boolean
+): ColorSetting[] => {
+  if (value?.light !== undefined && value.light === value.dark) {
+    return [{ path, presets, value: value.light }];
+  }
+  return MODES.flatMap((mode) => {
+    const color = value?.[mode];
+    return color === undefined
+      ? []
+      : [{ path: [...path, mode], presets, value: color }];
+  });
+};
+
+const OG_PALETTE_KEYS = [
+  "accent",
+  "background",
+  "border",
+  "foreground",
+  "muted",
+] as const;
+
+/**
+ * The configured colors that aren't CSS colors (`"deep purple"`, a hex value
+ * missing its `#`): `theme.accent`, `theme.action`, and `theme.background`,
+ * and the OG card's `seo.og.palette`. The schema takes any string, so a
+ * mistake would otherwise reach the stylesheet, where browsers drop it, or
+ * the card renderer, which rejects it. Preset names are CSS color names too.
+ */
+export const invalidColorSettings = (
+  config: ResolvedConfig
+): ColorSetting[] => {
+  const { theme } = config;
+  const palette = config.seo.og.palette ?? {};
+  return [
+    ...modeSettings(["theme", "accent"], theme.accent, true),
+    ...(theme.action === undefined
+      ? []
+      : [{ path: ["theme", "action"], presets: true, value: theme.action }]),
+    ...modeSettings(["theme", "background"], theme.background, false),
+    ...OG_PALETTE_KEYS.flatMap((key) => {
+      const value = palette[key];
+      return value === undefined
+        ? []
+        : [
+            {
+              path: ["seo", "og", "palette", key],
+              presets: key === "accent",
+              value,
+            },
+          ];
+    }),
+  ].filter((setting) => !isCssColor(setting.value));
+};