blume 2.1.0 → 2.1.2

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/lower.d.ts

@@ -45,6 +45,13 @@ export declare const codeSpan: (code: string) => string;
 export declare const guardBlockStart: (text: string) => string;
 /** A block's inline content as Markdown. */
 export declare const renderInline: (parts: InlinePart[]) => string;
+/**
+ * A block's inline content as MDX source, for a source whose site author
+ * opted in to reading its text that way: marks still become delimiters and
+ * code stays a code span, but the text goes in as typed, so a component, an
+ * expression, or Markdown written in the CMS renders.
+ */
+export declare const renderInlineMdx: (parts: InlinePart[]) => string;
 /** A link or image destination as Markdown carries it verbatim. */
 export declare const destination: (url: string) => string;
 /**
@@ -54,9 +61,10 @@ export declare const destination: (url: string) => string;
  * `data:`) never becomes a clickable link on the docs site (see
  * `safe-links.ts`). The parts stay parts then, so their runs merge with their
  * neighbors'. A label escapes a bare URL too: GFM autolinks nothing inside a
- * link, so its specials would read as syntax.
+ * link, so its specials would read as syntax — unless `mdx` reads the label
+ * as MDX source, like {@link renderInlineMdx}.
  */
-export declare const linkParts: (parts: InlinePart[], href?: string) => InlinePart[];
+export declare const linkParts: (parts: InlinePart[], href?: string, mdx?: boolean) => InlinePart[];
 /** The ATX prefix for a heading level, clamped to Markdown's six. */
 export declare const headingPrefix: (level: number) => string;
 /** Quote every line of a block. */

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/notion.d.ts

@@ -115,6 +115,14 @@ export interface NotionSourceOptions {
      * Status/select property are always imported as published.
      */
     publishedValue?: string;
+    /**
+     * Read the text of text blocks (paragraphs, headings, list items, quotes,
+     * callouts) as MDX source, so a component, expression, or Markdown typed in
+     * Notion renders instead of showing as written. MDX runs code at build
+     * time, so this hands everyone who can edit the database the site's build:
+     * set it only when you trust them with that. Default false.
+     */
+    mdx?: boolean;
     /** Opt-in dev polling interval (seconds); omit to freeze for the session. */
     pollInterval?: number;
     /** Injected for tests; otherwise built from `@notionhq/client`. */

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

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/cloudflare-negotiation.d.ts

@@ -40,8 +40,9 @@
  * Cloudflare does not apply `_headers` to worker-first routes, so the wrapper
  * also re-stamps what the static layer would otherwise add on the routes it
  * takes over: the homepage agent-discovery `Link` header, the Markdown
- * `charset=utf-8`, and the sandbox on the SVGs a content source downloaded
- * (see `deploy/headers.ts`). The raw `.md`/`.mdx` URLs are
+ * `charset=utf-8`, the sandbox on the SVGs a content source downloaded (see
+ * `deploy/headers.ts`), and `X-Powered-By` unless `poweredBy` is `false`. The
+ * raw `.md`/`.mdx` URLs are
  * exempted from worker-first routing with negative rules, keeping their
  * `_headers` treatment and their zero-Worker serving path.
  *
@@ -133,6 +134,8 @@ export interface NegotiationWorkerOptions {
     base?: string;
     /** Homepage agent-discovery `Link` header (see `ai/link-headers.ts`). */
     homeLinkHeader?: string | null;
+    /** Whether responses identify Blume with `X-Powered-By`. Defaults to `true`. */
+    poweredBy?: boolean;
     /** Estimated token count of the homepage Markdown mirror. */
     homeTokens?: number;
     /** Configured redirects the wrapper answers with their exact status. */

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

@@ -54,6 +54,8 @@ export declare const nodePatternRedirects: (project: BlumeProject) => CompiledRe
 export interface NodeEntryOptions {
     /** `deployment.base`, normalized (`""` at the root). */
     base?: string;
+    /** Whether responses identify Blume with `X-Powered-By`. Defaults to `true`. */
+    poweredBy?: boolean;
     /** The configured redirects, from {@link nodeRedirects}. */
     redirects?: NodeRedirects;
     /** The configured pattern redirects, from {@link nodePatternRedirects}. */
@@ -63,7 +65,12 @@ export interface NodeEntryOptions {
  * The entry that replaces Astro's: it answers a configured redirect with its
  * exact status, and otherwise stamps the rules' headers on the response and
  * hands the request to Astro's handler. `send` leaves a Content-Type that is
- * already set alone, so the registered media type wins.
+ * already set alone, so the registered media type wins. Unless `poweredBy` is
+ * `false`, every answer also names Blume in `X-Powered-By` — the redirects,
+ * and the prerendered pages and files the static handler serves, which
+ * Blume's runtime middleware never sees. A middleware-mode entry leaves that
+ * header to the middleware: Astro hands a request it has no route for back to
+ * the host app through `next()`, and that response is the host's own.
  *
  * A rule matches the file the static handler will serve, not the raw URL:
  * Astro strips the base when it leads the path and serves the rest from the
@@ -81,8 +88,9 @@ export interface NodeEntryOptions {
  */
 export declare const nodeEntryWrapper: (rules: readonly NodeHeaderRule[], options?: NodeEntryOptions) => string;
 /**
- * Put the wrapper in front of a Node server build's entry. A build with no
- * rule (no API catalog, AI catalog, MCP server, signatures directory, or
- * downloaded content assets) and no redirect leaves Astro's entry alone.
+ * Put the wrapper in front of a Node server build's entry. A build with
+ * `poweredBy` off, no rule (no API catalog, AI catalog, MCP server,
+ * signatures directory, or downloaded content assets), and no redirect leaves
+ * Astro's entry alone.
  */
 export declare const wrapNodeEntry: (project: BlumeProject, log: BuildLog) => Promise<void>;

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

@@ -34,12 +34,15 @@ export declare const nameCloudflareWorker: (project: BlumeProject, log: BuildLog
  */
 export declare const bindCloudflareRateLimit: (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.
+ * 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/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;

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

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