blume 2.0.3 → 2.1.1

package/dist/types/core/sources/cache.d.ts

@@ -33,5 +33,8 @@ export declare const snapshotCache: (cacheDir: string) => SnapshotCache;
  * snapshot exists, serve it without fetching (cache-first dev). On fetch failure,
  * serve the last-known-good snapshot with a warning so a CMS/network outage
  * doesn't fail the build; if there is no snapshot either, surface a hard error.
+ * A `BlumeError` from the source (a missing SDK or token, checked before any
+ * request, or a misconfiguration) already names its cause, so without a
+ * snapshot it surfaces as itself rather than as a fetch failure.
  */
 export declare const loadWithCache: (name: string, cache: SnapshotCache, fetchEntries: () => Promise<SourceEntry[]>, refresh?: boolean) => Promise<SourceLoadResult>;

package/dist/types/core/sources/contentful-rich-text.d.ts

@@ -1,20 +1,29 @@
 /**
  * Contentful rich text → Markdown. Covers the block, inline, and mark types
  * the Rich Text editor emits; embedded entries fall through to a serializer
- * keyed by content type or are noted in a comment. Links to assets and
+ * keyed by content type or are noted in a comment, and a link to an entry
+ * points at its page when the source says it has one. Links to assets and
  * entries arrive unresolved from the Delivery API (`data.target` is a
  * `sys` link), so the source hands in resolvers over the response's
  * `includes`; a document the SDK already resolved (with `fields` inline)
  * lowers the same way.
  */
 import type { JsonObject } from "./json.ts";
-/** An asset's file as a Markdown image needs it. */
+/** An asset's file as a Markdown image or link needs it. */
 export interface ContentfulAsset {
+    /** The file's MIME type; an asset that isn't an image renders as a link. */
+    contentType?: string;
     description?: string;
+    fileName?: string;
     title?: string;
     url: string;
 }
 export interface ContentfulRichTextOptions {
+    /**
+     * The route of a linked entry's page; an entry hyperlink to an entry with
+     * none keeps only its text.
+     */
+    entryHref?: (entry: JsonObject) => string | undefined;
     /** Resolve an asset link (`data.target.sys.id`) to its file. */
     resolveAsset?: (id: string) => ContentfulAsset | null;
     /** Resolve an entry link to the entry (`sys` plus `fields`). */

package/dist/types/core/sources/contentful.d.ts

@@ -1,3 +1,4 @@
+import type { ResolvedI18nConfig, ResolvedVersionsConfig } from "../schema.ts";
 import type { JsonObject } from "./json.ts";
 import type { RemoteFieldMap } from "./remote.ts";
 import type { ContentSource, SourceContext } from "./types.ts";
@@ -8,10 +9,24 @@ export interface ContentfulSourceOptions {
     space: string;
     /** Environment id; default `master`. */
     environment?: string;
+    /**
+     * Delivery API host name; default `cdn.contentful.com`. A space with EU
+     * data residency reads from `cdn.eu.contentful.com`.
+     */
+    host?: string;
+    /**
+     * Preview API host name for `--preview`; default `preview.contentful.com`
+     * (`preview.eu.contentful.com` for EU data residency).
+     */
+    previewHost?: string;
     /** The content type id whose entries become pages. */
     contentType: string;
     /** Locale code to fetch; omit for the space's default locale. */
     locale?: string;
+    /** The project's i18n config, which places an entry's route by its slug. */
+    i18n?: ResolvedI18nConfig;
+    /** The project's versions config, which places an entry's route by its slug. */
+    versions?: ResolvedVersionsConfig;
     /**
      * Field ids mapping an entry onto Blume meta + body. Paths resolve against
      * the entry's `fields`, with `sys` reachable as `sys.<key>`. Defaults:
@@ -35,6 +50,7 @@ export interface ContentfulSourceOptions {
  * Contentful content source. Pages through the Delivery API (the Preview API
  * under `--preview`), maps each entry's fields to frontmatter, and lowers its
  * rich text body to Markdown with the page's `includes` resolving asset and
- * entry links.
+ * entry links. An entry hyperlink to another of the source's entries links
+ * to that entry's page.
  */
 export declare const contentfulSource: (options: ContentfulSourceOptions, ctx?: SourceContext) => ContentSource;

package/dist/types/core/sources/lexical.d.ts

@@ -9,6 +9,11 @@ import type { JsonObject } from "./json.ts";
 export interface LexicalOptions {
     /** The CMS origin a relative upload URL (`/media/x.png`) resolves against. */
     baseUrl?: string;
+    /**
+     * Called with the label of each node left out as a comment (a block with
+     * no serializer, a node type with no Markdown), so the source can warn.
+     */
+    onUnsupported?: (what: string) => void;
     /** Serializers for `block`/`inlineBlock` nodes, keyed by `fields.blockType`. */
     serializers?: Record<string, (fields: JsonObject) => string>;
 }

package/dist/types/core/sources/normalize.d.ts

@@ -1,5 +1,6 @@
+import type { YAMLException } from "js-yaml";
 import type { ResolvedI18nConfig } from "../schema.ts";
-import type { Diagnostic, Heading, PageLink, PageRecord } from "../types.ts";
+import type { Diagnostic, ExampleUse, Heading, PageLink, PageRecord } from "../types.ts";
 import type { NormalizeContext, SourceEntry } from "./types.ts";
 /**
  * Slugify a content/route slug (Sanity, Notion, frontmatter `slug`). Heading
@@ -30,6 +31,16 @@ export declare const slugifyPath: (text: string) => string;
  * reports this instead of publishing a route that can never render.
  */
 export declare const unloadablePathDiagnostic: (path: string, file: string) => Diagnostic | undefined;
+/**
+ * The error for a content file whose front matter isn't valid YAML — most
+ * often an unquoted value holding `: `, which YAML reads as a nested mapping.
+ * Thrown out of a source's scan, it would fail every command with
+ * BLUME_INTERNAL; a source leaves the file out and reports this instead, like
+ * a page whose front matter fails the schema. js-yaml counts lines from the
+ * text after the opening `---`, which starts with the rest of that fence
+ * line, so its 0-based line is already the file's line minus one.
+ */
+export declare const frontmatterYamlDiagnostic: (error: YAMLException, file: string) => Diagnostic;
 export declare const HTML_COMMENT: RegExp;
 export declare const INLINE_CODE: RegExp;
 /** A heading whose trailing `{#id}` marker is unescaped — see `BARE_CURLY_MARKER`. */
@@ -37,6 +48,8 @@ export interface CurlyMarker {
     id: string;
     /** 1-based line of the heading (a setext heading's first text line) in the body. */
     line: number;
+    /** The braces as written (`{#id}`, `{ #id }`, `{: #id }`). */
+    marker: string;
 }
 /** Where a heading's text ends in the scanned text, for appending a marker. */
 export interface HeadingSite {
@@ -74,6 +87,12 @@ export declare const MD_IMAGE: RegExp;
 /** Column (0-based, within `matched`) where a link/image match's target starts. */
 export declare const targetOffsetIn: (matched: string, target: string, title: string | undefined) => number;
 export declare const extractLinks: (body: string, lineOffset?: number) => PageLink[];
+/**
+ * Every `<Component path>` in an `.mdx` body, with the 1-based position of its
+ * value; lines are shifted by `lineOffset`, as {@link extractLinks} does. Code
+ * blocks and inline code are skipped.
+ */
+export declare const extractExampleUses: (body: string, lineOffset?: number) => ExampleUse[];
 export declare const extractComponentTags: (body: string) => string[];
 /**
  * Height of the frontmatter block stripped from `raw` to produce `body` (0

package/dist/types/core/sources/read.d.ts

@@ -1,7 +1,12 @@
 import type { PageRecord } from "../types.ts";
+import type { ContentVariables } from "../variables.ts";
 import type { ContentSource } from "./types.ts";
 /** The subset of a scanned project the entry reader needs. */
 export interface EntryReadContext {
+    /** The site's content variables, substituted into what's read. */
+    config?: {
+        variables?: ContentVariables;
+    };
     /** The instantiated sources, keyed for `read()` lookups. */
     sources?: ContentSource[];
 }

package/dist/types/core/sources/remote.d.ts

@@ -1,3 +1,5 @@
+import { BlumeError } from "../diagnostics.ts";
+import type { Diagnostic } from "../types.ts";
 import type { JsonObject, JsonValue } from "./json.ts";
 import type { ContentSource, SourceContext, SourceEntry } from "./types.ts";
 /** What every REST-backed CMS source needs to be a staged, cached source. */
@@ -9,8 +11,13 @@ export interface RemoteSourceOptions {
      * offline warning.
      */
     assertConfigured?: () => void;
-    /** Pull every entry from the API; called on refresh and on each poll. */
-    fetchEntries: () => Promise<SourceEntry[]>;
+    /**
+     * Pull every entry from the API; called on refresh and on each poll.
+     * `warn` reports a problem with the content itself (an embed the API
+     * couldn't resolve, a node with no Markdown), which the load returns
+     * beside the entries; a load served from the snapshot repeats none.
+     */
+    fetchEntries: (warn: (diagnostic: Diagnostic) => void) => Promise<SourceEntry[]>;
     name: string;
     /** Opt-in dev polling interval (seconds); omit to freeze for the session. */
     pollInterval?: number;
@@ -29,6 +36,9 @@ export declare const remoteSource: (options: RemoteSourceOptions, ctx?: SourceCo
 export interface RemoteFrontmatter {
     description?: string;
     draft?: boolean;
+    sidebar?: {
+        order: number;
+    };
     title?: string;
 }
 /**
@@ -37,6 +47,13 @@ export interface RemoteFrontmatter {
  * `writesMdx`).
  */
 export declare const stagedEntry: (slug: string, data: RemoteFrontmatter, markdown: string, lastModified: string | undefined, format?: "md" | "mdx") => SourceEntry;
+/**
+ * The error a source throws before its first request when the token its API
+ * always requires is unset (Notion, Contentful's Delivery API). Sent without
+ * one, the request could only fail, and the build would report the API's
+ * wording as a fetch failure instead of the variable to set.
+ */
+export declare const missingSecretError: (name: string, env: string) => BlumeError;
 /** How a source calls its CMS: the API's auth headers and an injectable fetch. */
 export interface RestClient {
     /** Injected for tests; defaults to the global `fetch`. */
@@ -67,18 +84,28 @@ export interface RemoteFieldMap {
     description?: string;
     /** Field holding the last-modified ISO date. */
     lastModified?: string;
+    /** Field holding the sidebar order (a number); no default. */
+    order?: string;
     /** Field holding the route slug. */
     slug?: string;
     /** Field holding the page title. */
     title?: string;
 }
+/** A field map with its defaults filled in; `order` is read only when set. */
+export type RemoteFields = Required<Omit<RemoteFieldMap, "order">> & Pick<RemoteFieldMap, "order">;
+/**
+ * The slug a document's staged entry is named by. It falls back to the
+ * document's id when the slug field is missing or slugifies to nothing (pure
+ * punctuation), so distinct documents never collapse onto one
+ * `untitled.md`; a slashed slug keeps its segments.
+ */
+export declare const documentSlug: (doc: JsonObject, slugField: string, id: string) => string;
 /**
- * Map a document to a staged entry. The slug falls back to the document's id
- * when the slug field is missing or slugifies to nothing (pure punctuation),
- * so distinct documents never collapse onto one `untitled.md`; a slashed
- * slug keeps its segments. A string body is Markdown and passes through as
- * `.md`, its unsafe links reduced to their labels; any other shape goes to
- * the CMS's lowerer, and is written as `.mdx`
- * when `lowersToMdx` (the source has serializers, see `writesMdx`).
+ * Map a document to a staged entry named by its {@link documentSlug}. A
+ * number in the `order` field, when one is mapped, becomes the page's
+ * sidebar order. A string body is Markdown and passes through as `.md`, its
+ * unsafe links reduced to their labels; any other shape goes to the CMS's
+ * lowerer, and is written as `.mdx` when `lowersToMdx` (the source has
+ * serializers, see `writesMdx`).
  */
-export declare const documentEntry: (doc: JsonObject, fields: Required<RemoteFieldMap>, id: string, lower: (body: JsonValue) => string, draft?: boolean, lowersToMdx?: boolean) => SourceEntry;
+export declare const documentEntry: (doc: JsonObject, fields: RemoteFields, id: string, lower: (body: JsonValue) => string, draft?: boolean, lowersToMdx?: boolean) => SourceEntry;

package/dist/types/core/sources/sanity.d.ts

@@ -12,7 +12,7 @@ export interface SanityFieldMap {
     description?: string;
     /** Route slug (dot path); default `slug.current`. */
     slug?: string;
-    /** Portable Text body field; default `body`. */
+    /** Body field, Portable Text or a Markdown string; default `body`. */
     body?: string;
     /** Last-modified ISO date; default `_updatedAt`. */
     lastModified?: string;

package/dist/types/core/types.d.ts

@@ -51,6 +51,10 @@ export interface PageLink {
      * only those go through the image pipeline; a plain link to the same path
      * resolves as a site route. */
     image?: boolean;
+    /** Set when the target is a lowercase `<a href>`, which ships as written:
+     * the Markdown pipeline neither resolves its relative path file-style nor
+     * mounts the base path on it, so it's checked the way a browser reads it. */
+    raw?: boolean;
     /** 1-based line number in the source file. */
     line: number;
     /** 1-based column of the target within the line. */
@@ -60,6 +64,17 @@ export interface PageLink {
      * here so authors fix the partial, not the page that spliced it. */
     file?: string;
 }
+/** A `<Component path="…">` in a page, located like a {@link PageLink}. */
+export interface ExampleUse {
+    /** The example's key as written: its path under `examples/`, sans extension. */
+    path: string;
+    /** 1-based line number in the source file. */
+    line: number;
+    /** 1-based column of the `path` value within the line. */
+    column: number;
+    /** Absolute path of the included partial it was written in, if not the page. */
+    file?: string;
+}
 /**
  * Resolved project paths. Computed once per CLI invocation and threaded
  * through the core pipeline.
@@ -185,6 +200,8 @@ export interface PageRecord {
     links: PageLink[];
     /** Capitalized JSX component tags used in the body (`.mdx` only). */
     componentsUsed?: string[];
+    /** The string `path` of each `<Component>` example in the body (`.mdx` only). */
+    examplesUsed?: ExampleUse[];
     /** Resolved "last updated" ISO date, when the feature is enabled. */
     lastModified?: string;
     /** Absolute paths of files this page `<include>`s, transitively. Drives the
@@ -297,7 +314,7 @@ export interface Navigation {
     cta?: HeaderAction | null;
     /** Pinned links shown above the sidebar sections, unscoped by tab. */
     featured: FeaturedLink[];
-    /** Repo URL for the header link, or null when hidden (`navigation.repo`). */
+    /** Repo URL for the footer's GitHub link, or null when hidden (`navigation.repo`). */
     repoUrl?: string | null;
     /**
      * Where the header's brand link points in this locale: `logo.href` moved

package/dist/types/core/variables.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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 declare const VARIABLE_NAME: RegExp;
+/** Whether a site defines any variables, so the rest can be skipped. */
+export declare const hasVariables: (variables?: ContentVariables) => variables is ContentVariables;
+/** `text` with every reference to a defined variable replaced by its value. */
+export declare const substituteVariables: (text: string, variables?: ContentVariables) => string;
+/**
+ * {@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 declare const substituteVariablesInBody: (source: string, variables?: ContentVariables) => string;
+/** An undefined variable referenced in prose, with its 1-based line. */
+export interface UndefinedVariable {
+    line: number;
+    name: string;
+}
+/**
+ * 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 declare const undefinedVariables: (text: string, variables?: ContentVariables) => UndefinedVariable[];

package/dist/types/deploy/adapter-output.d.ts

@@ -13,7 +13,8 @@ export declare const deployOutputDir: (config: ResolvedConfig, context: ProjectC
  * 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 declare const deployStaticDir: (config: ResolvedConfig, context: ProjectContext) => string;
 /**

package/dist/types/deploy/adapters/cloudflare.d.ts

@@ -31,10 +31,12 @@ export declare const cloudflareAdapterSchema: import("zod").ZodObject<{
     runtimeDeps: import("zod").ZodArray<import("zod").ZodString>;
 }, import("zod/v4/core").$strict>;
 /**
- * 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 declare const cloudflare: (options?: CloudflareOptions) => CloudflareAdapter;

package/dist/types/deploy/adapters/node.d.ts

@@ -1,37 +1,72 @@
+import { z } from "zod";
 import type { DeployAdapter, DeployOptions } from "./types.ts";
 /** The Astro adapter package a Node server build imports. */
 export declare 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;
-export type NodeAdapter = DeployAdapter<"node">;
-export declare const nodeOptionsSchema: import("zod").ZodObject<{
-    base: import("zod").ZodOptional<import("zod").ZodString>;
-    output: import("zod").ZodOptional<import("zod").ZodEnum<{
+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;
+};
+/**
+ * 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 type NodeAdapter = DeployAdapter<"node", NodeOptions>;
+export declare const nodeOptionsSchema: z.ZodObject<{
+    base: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodEnum<{
         static: "static";
         server: "server";
     }>>;
-    site: import("zod").ZodOptional<import("zod").ZodURL>;
-}, import("zod/v4/core").$catchall<import("zod").ZodJSONSchema>>;
-export declare const nodeAdapterSchema: import("zod").ZodObject<{
-    kind: import("zod").ZodLiteral<"node">;
-    options: import("zod").ZodObject<{
-        base: import("zod").ZodOptional<import("zod").ZodString>;
-        output: import("zod").ZodOptional<import("zod").ZodEnum<{
+    site: z.ZodOptional<z.ZodURL>;
+    allowedDomains: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        hostname: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodString>;
+        protocol: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$catchall<z.ZodJSONSchema>>;
+export declare const nodeAdapterSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"node">;
+    options: z.ZodObject<{
+        base: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodEnum<{
             static: "static";
             server: "server";
         }>>;
-        site: import("zod").ZodOptional<import("zod").ZodURL>;
-    }, import("zod/v4/core").$catchall<import("zod").ZodJSONSchema>>;
-    requiredSecrets: import("zod").ZodArray<import("zod").ZodString>;
-    runtimeDeps: import("zod").ZodArray<import("zod").ZodString>;
-}, import("zod/v4/core").$strict>;
+        site: z.ZodOptional<z.ZodURL>;
+        allowedDomains: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            hostname: z.ZodOptional<z.ZodString>;
+            port: z.ZodOptional<z.ZodString>;
+            protocol: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$catchall<z.ZodJSONSchema>>;
+    requiredSecrets: z.ZodArray<z.ZodString>;
+    runtimeDeps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
 /**
  * A self-hosted Node server (containers, VMs). The standalone server in
  * `dist/server/entry.mjs` serves `dist/client` itself. `@astrojs/node` is one

package/dist/types/deploy/adapters/registry.d.ts

@@ -67,6 +67,11 @@ export declare const resolvedDeploymentSchema: z.ZodPipe<z.ZodDiscriminatedUnion
             server: "server";
         }>>;
         site: z.ZodOptional<z.ZodURL>;
+        allowedDomains: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            hostname: z.ZodOptional<z.ZodString>;
+            port: z.ZodOptional<z.ZodString>;
+            protocol: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
     }, z.core.$catchall<z.ZodJSONSchema>>;
     requiredSecrets: z.ZodArray<z.ZodString>;
     runtimeDeps: z.ZodArray<z.ZodString>;
@@ -113,6 +118,11 @@ export declare const resolvedDeploymentSchema: z.ZodPipe<z.ZodDiscriminatedUnion
         base?: string | undefined;
         output?: "static" | "server" | undefined;
         site?: string | undefined;
+        allowedDomains?: {
+            hostname?: string | undefined;
+            port?: string | undefined;
+            protocol?: string | undefined;
+        }[] | undefined;
     };
     requiredSecrets: string[];
     runtimeDeps: string[];

package/dist/types/deploy/adapters/types.d.ts

@@ -67,9 +67,10 @@ export declare const deployOptionsSchema: z.ZodObject<{
 }, z.core.$catchall<z.ZodJSONSchema>>;
 /**
  * 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 declare const deployPassthrough: (options: DeployOptions) => Record<string, JsonValue>;
+export declare const deployPassthrough: (options: DeployOptions, configOptions?: readonly string[]) => Record<string, JsonValue>;
 /**
  * The runtime dependency a host adapter declares: its `@astrojs/*` package,
  * which the generated `astro.config.mjs` imports for a server build and

package/dist/types/deploy/node-headers.d.ts

@@ -1,4 +1,5 @@
 import type { BlumeProject } from "../core/project-graph.ts";
+import type { CompiledRedirect } from "../core/redirect-patterns.ts";
 import type { ResolvedConfig } from "../core/schema.ts";
 import type { BuildLog } from "./platforms/types.ts";
 /**
@@ -34,19 +35,29 @@ export declare const nodeHeaderRules: (config: ResolvedConfig) => NodeHeaderRule
  */
 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 declare 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 declare const nodePatternRedirects: (project: BlumeProject) => CompiledRedirect[];
 /** 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[];
 }
 /**
  * The entry that replaces Astro's: it answers a configured redirect with its

package/dist/types/deploy/platforms/cloudflare.d.ts

@@ -29,12 +29,20 @@ export declare const emitCloudflareDeployConfig: (context: ProjectContext) => Pr
  */
 export declare const nameCloudflareWorker: (project: BlumeProject, log: BuildLog) => Promise<void>;
 /**
- * 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.
+ * Declare the Workers rate limiting binding `rateLimit: cloudflare()` counts
+ * with in the built Worker's config, which `wrangler deploy` reads.
+ */
+export declare const bindCloudflareRateLimit: (project: BlumeProject, log: BuildLog) => Promise<void>;
+/**
+ * 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 declare const cloudflarePlatform: DeployPlatform;

package/dist/types/deploy/platforms/netlify.d.ts

@@ -26,6 +26,13 @@ export declare const NETLIFY_CONFIG_FILE: string;
  * as static files, so the prerendered endpoint's own headers never ship.
  */
 export declare const emitNetlifyHeaders: (project: BlumeProject, log: BuildLog) => Promise<void>;
+/**
+ * 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 declare const emitNetlifyPatternRedirects: (project: BlumeProject) => Promise<void>;
 /**
  * Netlify. A server build runs on Netlify Functions from the Frameworks API
  * tree the adapter writes to `.netlify/v1`, relative to the Astro root —

package/dist/types/deploy/platforms/node.d.ts

@@ -7,6 +7,8 @@ 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 declare const nodePlatform: DeployPlatform;