blume 2.0.1 → 2.0.3

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

@@ -4,6 +4,10 @@
  * blocks) renders inline runs, wraps them in block syntax, and joins blocks
  * with blank lines; these helpers keep that Markdown identical across them.
  */
+/**
+ * CMS text as Markdown that renders as written, wherever it lands — a link
+ * label included, where GFM autolinks nothing, so every special is escaped.
+ */
 export declare const escapeMarkdownText: (text: string) => string;
 /** The marks a lowerer can put on an inline run. */
 export interface InlineMarks {
@@ -12,6 +16,17 @@ export interface InlineMarks {
     italic?: boolean;
     strike?: boolean;
 }
+/** A run of CMS text and the marks on it. */
+export interface InlineRun {
+    marks: InlineMarks;
+    text: string;
+}
+/** Inline Markdown a lowerer rendered itself: a link, an embed, a break. */
+export interface InlineMarkdown {
+    markdown: string;
+}
+/** One piece of a block's inline content, in order. */
+export type InlinePart = InlineMarkdown | InlineRun;
 /**
  * A code span whose delimiter outruns any backtick run inside it, padded with
  * a space on each side when the code starts or ends with a backtick (the
@@ -19,22 +34,29 @@ export interface InlineMarks {
  */
 export declare const codeSpan: (code: string) => string;
 /**
- * Wrap a text run in the Markdown for its marks. Code stays verbatim inside
- * the backticks (an escape would render as a backslash); everything else is
- * escaped first. Whitespace at either edge moves outside the delimiters,
- * since `** bold **` is not strong emphasis but `**bold**` is — editors
- * routinely bold a word together with the space after it.
+ * A block's inline text, guarded where only the whole block can tell. Runs
+ * are escaped one at a time, but "import" ending one run and a space or code
+ * span opening the next form an MDX `import` statement only once they are
+ * joined, whitespace the first runs put in front of a block turns it into
+ * an indented code block, two struck runs fuse into literal tildes, and a
+ * trailing ` #` is a heading's closing sequence. Apply it to the joined text
+ * of a paragraph, heading, quote, or list item — never to code.
  */
-export declare const renderInline: (text: string, marks: InlineMarks) => string;
-/** A link or image destination as Markdown can carry it verbatim. */
+export declare const guardBlockStart: (text: string) => string;
+/** A block's inline content as Markdown. */
+export declare const renderInline: (parts: InlinePart[]) => string;
+/** A link or image destination as Markdown carries it verbatim. */
 export declare const destination: (url: string) => string;
 /**
- * A Markdown link, or the label alone when the target is missing — or unsafe:
- * CMS content is the editor's, not the site author's, so a destination that
- * isn't a web, mail, or relative address (`javascript:`, `data:`) never
- * becomes a clickable link on the docs site (see `safe-links.ts`).
+ * A Markdown link over inline parts, or the parts alone when the target is
+ * missing — or unsafe: CMS content is the editor's, not the site author's, so
+ * a destination that isn't a web, mail, or relative address (`javascript:`,
+ * `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.
  */
-export declare const renderLink: (label: string, href?: string) => string;
+export declare const linkParts: (parts: InlinePart[], href?: string) => 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. */
@@ -46,7 +68,10 @@ export declare const blockquote: (text: string) => string;
 export declare const listItem: (marker: string, body: string) => string;
 /** Indent every non-empty line, for a nested list hanging off an item. */
 export declare const indent: (text: string, width: number) => string;
-/** A fenced code block whose fence outruns any backtick run in the code. */
+/**
+ * A fenced code block whose fence outruns any backtick run in the code,
+ * labeled with its language when that is one word a fence can carry.
+ */
 export declare const codeFence: (code: string, language?: string) => string;
 /** A Markdown image; the alt is escaped so a `]` in a caption can't close it. */
 export declare const image: (alt: string, url: string) => string;

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

@@ -21,6 +21,15 @@ export declare const slugify: (text: string) => string;
  * document. Each segment is slugged on its own and the separators kept.
  */
 export declare const slugifyPath: (text: string) => string;
+/**
+ * The error for a content file Astro's content loader can't read, or
+ * undefined when it can. A `#` or `?` anywhere in the path the loader is
+ * handed (`sdks/c#.md`, `faq/why?.md`) truncates the file URL it reads
+ * through, so the read fails with ENOENT and the page renders "Page not
+ * found" at its route. A source leaves such a file out of its scan and
+ * reports this instead of publishing a route that can never render.
+ */
+export declare const unloadablePathDiagnostic: (path: string, file: string) => Diagnostic | undefined;
 export declare const HTML_COMMENT: RegExp;
 export declare const INLINE_CODE: RegExp;
 /** A heading whose trailing `{#id}` marker is unescaped — see `BARE_CURLY_MARKER`. */
@@ -54,7 +63,10 @@ export interface BodyScan {
 /**
  * Scan a body for its headings, explicit HTML anchors, and unescaped `{#id}`
  * markers in one fence-aware walk (the same walk `extractHeadings` exposes for
- * headings alone).
+ * headings alone). The body is the page's content with its front matter
+ * already stripped — the renderers read front matter off the page and never
+ * again from its body — so a leading `---` block is a thematic break and
+ * content, in `.md` and `.mdx` alike.
  */
 export declare const scanBody: (body: string) => BodyScan;
 export declare const extractHeadings: (body: string) => Heading[];
@@ -74,6 +86,13 @@ export declare const strippedLineOffset: (raw: string | undefined, body: string)
 export declare const isStringValue: (value: SourceEntry["data"][string]) => value is string;
 /** What a route resolution needs from the owning source and the config. */
 export type RouteContext = Pick<NormalizeContext, "i18n" | "versions"> & {
+    /**
+     * Whether the entry's ref is a path of file and folder names whose ordering
+     * prefixes (`01-intro`) sort the sidebar and drop from the route: true for
+     * filesystem sources. A staged source's ref is a slug, a release tag, or a
+     * note name, and keeps its leading numbers.
+     */
+    orderingPrefixes?: boolean;
     /** The source's route prefix (`NormalizeContext["source"]["prefix"]`). */
     prefix?: string;
 };
@@ -123,7 +142,9 @@ export interface EntryRoute extends Pick<EntryPlacement, "locales" | "version">
  * A frontmatter `slug` wins, then the adapter-supplied `entry.slug` (the typed
  * SPI's "logical route input; defaults to ref if omitted"), then the ref. The
  * extension is re-appended so `mapRoute`'s extname strip can't eat a dotted
- * slug segment (`v1.2`). A slug that trims to nothing falls back. The version
+ * slug segment (`v1.2`). A slug that trims to nothing falls back. Only a
+ * filesystem ref (`ctx.orderingPrefixes`) loses its ordering prefixes; a slug
+ * is a route spelled out, so `2024-year-in-review` stays whole. The version
  * prefixes the mapped route *after* `mapRoute` runs: the mapped route is the
  * version-agnostic key, the config id is prepended verbatim (never
  * numeric-prefix-stripped), a frontmatter `slug` gets versionized so snapshots

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

@@ -2,12 +2,21 @@ 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. */
 export interface RemoteSourceOptions {
+    /**
+     * Throw a `BlumeError` when the source cannot load as configured. Runs
+     * before the cache is consulted: thrown from `fetchEntries` instead, a
+     * misconfiguration would be served over by a stale snapshot with only an
+     * offline warning.
+     */
+    assertConfigured?: () => void;
     /** Pull every entry from the API; called on refresh and on each poll. */
     fetchEntries: () => Promise<SourceEntry[]>;
     name: string;
     /** Opt-in dev polling interval (seconds); omit to freeze for the session. */
     pollInterval?: number;
     prefix?: string;
+    /** The adapter rebuilt on another context (`ContentSource.withContext`). */
+    withContext?: (ctx: SourceContext) => ContentSource;
 }
 /**
  * The staged-source scaffolding a CMS adapter shares: a snapshot cache under
@@ -68,7 +77,8 @@ export interface RemoteFieldMap {
  * 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`; any other shape goes to the CMS's lowerer, and is written as `.mdx`
+ * `.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;

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

@@ -1,3 +1,4 @@
+import type { ContentSourceAdapter } from "../../sources/registry.ts";
 import type { ResolvedConfig } from "../schema.ts";
 import type { ProjectContext } from "../types.ts";
 import type { ContentSource } from "./types.ts";
@@ -9,6 +10,17 @@ export interface SourceRuntime {
     preview?: boolean;
     refresh?: boolean;
 }
+/**
+ * The directory under `.blume/cache/<source>/` a source keeps its snapshot in:
+ * one per preview mode and set of adapter options. A preview snapshot holds
+ * drafts, so a published load must never read it, neither as dev's cache-first
+ * snapshot nor as a build's offline fallback; and a snapshot fetched with
+ * another `query` or `fields` is another result, not a cached copy of this
+ * one. `pollInterval` only paces dev re-fetches, so it is left out. A
+ * `custom()` source is a live instance rather than options, so its snapshot
+ * is keyed by preview mode alone.
+ */
+export declare const snapshotKey: (adapter: ContentSourceAdapter, runtime: SourceRuntime) => string;
 /**
  * Build the ordered list of content sources for a project. The config schema
  * already desugared the zero-config shorthand into a single `filesystem()`

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

@@ -35,6 +35,13 @@ export interface SourceEntry {
      * the owning source to expose a `contentRoot` to bound the log's pathspec.
      */
     sourcePath?: string;
+    /**
+     * How many lines of the file at `sourcePath` sit above `body.text`, when
+     * `raw` is not that file's text: a source that rewrites a local file's
+     * front matter (an Obsidian note) sets it, so a diagnostic points at the
+     * line the author wrote. Otherwise the height of `raw`'s front matter.
+     */
+    bodyLineOffset?: number;
     /** Optional provenance for "edit this page". */
     editUrl?: string;
     /** Optional last-modified ISO date supplied by the adapter (non-filesystem). */
@@ -119,6 +126,14 @@ export interface ContentSource {
      * switcher, since every other locale would only repeat the same text.
      */
     readonly monolingual?: boolean;
+    /**
+     * True for a staged source whose entry refs are file and folder names (an
+     * Obsidian vault), so their ordering prefixes (`01 Intro`) sort the sidebar
+     * and drop from the route the way a filesystem source's do. Filesystem
+     * sources always do; other staged refs are slugs and release tags, kept
+     * whole.
+     */
+    readonly orderedNames?: boolean;
     /**
      * Resolved on-disk root, set by sources whose entries live on disk. For
      * filesystem sources it drives folder-meta discovery (scan under this root)
@@ -128,6 +143,13 @@ export interface ContentSource {
      * no local tree.
      */
     readonly contentRoot?: string;
+    /**
+     * The globs a filesystem source reads under `contentRoot`, and the ones it
+     * skips. Folder-meta discovery honors them, so a `meta.ts` outside the
+     * content the source reads is never imported.
+     */
+    readonly include?: readonly string[];
+    readonly exclude?: readonly string[];
     /** Pull every entry. Called once per scan. */
     load: () => Promise<SourceLoadResult>;
     /** Validate the source is usable; throws a BlumeError when not. */
@@ -139,12 +161,21 @@ export interface ContentSource {
      * remote/static sources omit it (content is frozen for the session).
      */
     watch?: (onChange: () => void) => () => void;
+    /**
+     * This source rebuilt on another runtime context. A source passed to
+     * `custom()` is constructed before Blume knows the scan's preview flag,
+     * refresh policy, or runtime directory; Blume rebuilds it on them through
+     * this, so it previews and caches the way the built-in adapter does. The
+     * engine factories (`sanitySource`, `contentfulSource`, …) all set it.
+     */
+    withContext?: (ctx: SourceContext) => ContentSource;
 }
 /** Context passed to `normalizeEntry`, describing the owning source. */
 export interface NormalizeContext {
     source: {
         monolingual?: boolean;
         name: string;
+        orderedNames?: boolean;
         prefix?: string;
         staged: boolean;
     };

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

@@ -32,14 +32,21 @@ export declare const baselineScanIgnore: () => string[];
  * the scan share the same never-content directory set.
  */
 export declare const BLUME_WATCH_IGNORE_DIRS: string[];
-/** Extract single-segment ignore dirs (`foo`) from `foo/**`-style excludes. */
+/**
+ * Extract root-anchored ignore dirs (`/foo`) from `foo/**`-style excludes. The
+ * scan's glob `foo/**` matches `foo` at the source root only, so the watcher
+ * skips that one directory: a nested `guides/foo/` is still content, and an
+ * edit there must still reload.
+ */
 export declare const excludeDirSegments: (patterns: readonly string[]) => string[];
 /**
  * Build a recursive-watch listener that fires `onChange` for content changes but
- * ignores events whose path crosses an ignored directory segment — one in
- * `ignoreDirs`, or one `ignoreSegment` rejects, for a scan whose skip rule is
- * a shape (every dot-name) rather than a list. A missing `filename` — rare;
- * the platform couldn't name the changed path — falls through to `onChange`
+ * ignores events whose path crosses an ignored directory — a segment named in
+ * `ignoreDirs` at any depth, or one `ignoreSegment` rejects, for a scan whose
+ * skip rule is a shape (every dot-name) rather than a list. An entry written
+ * with a leading slash (`/drafts`, see {@link excludeDirSegments}) names a
+ * directory at the watched root only. A missing `filename` — rare; the
+ * platform couldn't name the changed path — falls through to `onChange`
  * rather than silently dropping a real edit. Exported for testing.
  */
 export declare const ignoringWatchListener: (onChange: () => void, ignoreDirs?: Iterable<string>, ignoreSegment?: (segment: string) => boolean) => WatchListener<string>;

package/dist/types/core/standard-schema.d.ts

@@ -41,5 +41,10 @@ export interface StandardSchema<Input = unknown, Output = Input> {
  * Whether a config-supplied value implements the `~standard` contract. Generic
  * so it can decode any input at the config boundary (`z.custom` hands it the
  * raw config value) while narrowing whatever type the caller holds.
+ *
+ * The contract is the `~standard` property, whatever carries it: Zod and
+ * Valibot schemas are objects, but an ArkType type is a callable function. The
+ * optional-chained probe reads the property off either, and off `null`,
+ * `undefined`, or a primitive it finds nothing.
  */
 export declare const isStandardSchema: <T>(value: T) => value is T & StandardSchema;

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

@@ -306,6 +306,13 @@ export interface Navigation {
      * locale trees.
      */
     brandHref?: string;
+    /**
+     * Where the banner's link points in this locale: `banner.link.href`
+     * localized like a featured link, then mounted under `basePath` (a route
+     * served outside the content tree keeps its own path). Set when the banner
+     * has a link.
+     */
+    bannerHref?: string;
 }
 /** The full content graph: the source of truth for generated modules. */
 export interface ContentGraph {
@@ -392,6 +399,8 @@ export interface RouteManifestEntry {
     fallback?: boolean;
     /** True when the page's source publishes one language only (no switcher). */
     monolingual?: boolean;
+    /** True when front matter `ai.exclude` keeps the page out of llms.txt. */
+    aiExclude?: boolean;
     /** Resolved "last updated" ISO date, when the feature is enabled. */
     lastModified?: string;
 }

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

@@ -3,8 +3,11 @@ import type { DeployAdapter, DeployOptions } from "./types.ts";
 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`, `host`, `port`, …). Blume
- * defaults `mode` to `"standalone"`; an option you pass wins.
+ * `@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;
 export type NodeAdapter = DeployAdapter<"node">;

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

@@ -49,6 +49,13 @@ export interface StaticDeployment {
      */
     site?: string;
 }
+/**
+ * `deployment.site`: an absolute http(s) URL, which always has a host. A bare
+ * `z.url()` takes any scheme, so `localhost:4321` (scheme `localhost:`),
+ * `mailto:`, and `javascript:` all passed and became the prefix of every
+ * sitemap entry and canonical link.
+ */
+export declare const siteUrlSchema: z.ZodURL;
 /** The named options' schema; every host adapter extends it with `z.json()` passthrough. */
 export declare const deployOptionsSchema: z.ZodObject<{
     base: z.ZodOptional<z.ZodString>;

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

@@ -8,10 +8,12 @@ import type { BlumeProject } from "../core/project-graph.ts";
  * Written from the integration's `astro:build:done` hook — Astro's channel
  * for exactly this kind of post-build work — into the directory Astro
  * reports as the client output (`dist/`, or `dist/client` for a server
- * build). The Vercel adapter copies that directory into its Build Output
- * static tree in a later hook, so the artifacts ride along; every other
- * adapter serves it directly. Running inside the hook rather than after
- * `astro build` returns means an ejected project keeps producing them.
+ * build, or `dist/client/<base>/` on Cloudflare, whose `_headers` goes to
+ * the root the platform serves above it). The Vercel adapter copies that
+ * directory into its Build Output static tree in a later hook, so the
+ * artifacts ride along; every other adapter serves it directly. Running
+ * inside the hook rather than after `astro build` returns means an ejected
+ * project keeps producing them.
  *
  * Every file yields to one the user ships in `public/` (Astro copied it into
  * the output before this runs).

package/dist/types/deploy/cloudflare-negotiation.d.ts

@@ -39,8 +39,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 and the Markdown
- * `charset=utf-8` (see `deploy/headers.ts`). The raw `.md`/`.mdx` URLs are
+ * 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
  * exempted from worker-first routing with negative rules, keeping their
  * `_headers` treatment and their zero-Worker serving path.
  *

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

@@ -1,11 +1,24 @@
 import type { ResolvedConfig } from "../core/schema.ts";
+/** Where the generated endpoint serves content-source images from. */
+export declare const CONTENT_ASSETS_ROOT = "/blume-assets";
 /**
  * The policy a content-source SVG is served with: an opaque origin with
  * scripts off, so an uploaded SVG that carries a `<script>` stays inert when
- * opened directly. The endpoint sends it from the server and dev runtimes;
- * {@link headerRules} carries it to static hosts.
+ * opened directly.
  */
 export declare const SVG_ASSET_POLICY = "sandbox";
+/**
+ * The headers a content-source SVG is served with: the sandbox policy, and no
+ * MIME sniffing. The endpoint sends them from the dev runtime; every host
+ * gets them for the built files — static hosts through {@link headerRules},
+ * server builds through each platform's own mechanism (`deploy/platforms`).
+ */
+export declare const SVG_ASSET_HEADERS: {
+    "Content-Security-Policy": string;
+    "X-Content-Type-Options": string;
+};
+/** The served glob of content-source SVGs, under the deployment base. */
+export declare const svgAssetPath: (config: ResolvedConfig) => string;
 /**
  * One static-host header rule: a served path (a `*` glob spanning path
  * segments, or an exact path) and the header it sets there.
@@ -17,11 +30,9 @@ export interface HeaderRule {
 }
 /**
  * The header rules every static host should apply, in `_headers` glob syntax.
- * The glob carries the served prefix (`{deployment.base}{basePath}` for the
- * Markdown mirrors, `{deployment.base}` for the root `.txt` files) so the rules
- * still match once the site is mounted under a subpath (`/docs/*.md`); the
- * wildcard spans path segments, so a nested route like `/docs/ja/intro.md`
- * matches too.
+ * The glob carries the deployment base so the rules still match once the site
+ * is mounted under a subpath (`/docs/*.md`); the wildcard spans path
+ * segments, so a nested route like `/docs/ja/intro.md` matches too.
  *
  * When a homepage `Link` header is provided (see `ai/link-headers.ts`), an
  * exact-path rule for the root page advertises the agent-discovery resources —
@@ -33,6 +44,19 @@ export declare const headerRules: (config: ResolvedConfig, homeLinkHeader?: stri
  * indented header line, in the two-space format Netlify and Cloudflare read.
  */
 export declare const buildNetlifyHeaders: (config: ResolvedConfig, homeLinkHeader?: string | null) => string;
+/** One entry of Netlify's Frameworks API config `headers` array. */
+export interface NetlifyConfigHeaders {
+    for: string;
+    values: Record<string, string>;
+}
+/**
+ * The {@link headerRules} as Netlify Frameworks API `headers` entries
+ * (`.netlify/v1/config.json`), one per path with every header it sets. A
+ * `netlify()` server build reads no `_headers` file, so it carries the same
+ * rules here, in the `for`/`values` form that follows `netlify.toml`'s
+ * `[[headers]]` and the same path syntax as `_headers`.
+ */
+export declare const buildNetlifyConfigHeaders: (config: ResolvedConfig, homeLinkHeader?: string | null) => NetlifyConfigHeaders[];
 /** One entry of `vercel.json`'s `headers` array. */
 export interface VercelHeader {
     headers: {
@@ -41,6 +65,11 @@ export interface VercelHeader {
     }[];
     source: string;
 }
+/**
+ * A literal path as `path-to-regexp` source text — what a `vercel.json`
+ * `source` is — with each syntax character escaped, so it matches only itself.
+ */
+export declare const escapeVercelSource: (path: string) => string;
 /**
  * The {@link headerRules} as `vercel.json` `headers` entries. Vercel reads no
  * `_headers` file, so a static deploy of `dist/` carries the same rules here —

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

@@ -10,6 +10,12 @@ import type { BuildLog } from "./platforms/types.ts";
  * (`deploy/headers.ts`) that a Node server has no file to read from. The Markdown
  * and text charsets need no rule here: `send` already adds `charset=UTF-8` to
  * `text/*` types.
+ *
+ * The same wrapper answers the configured redirects. Astro's own handler
+ * honors a redirect's configured status only when its destination resolves
+ * to a discrete route, and Blume serves every page from `[...slug]`, so a
+ * `302` or `307` would go out as a `301` or `308` — permanent redirects that
+ * browsers cache.
  */
 /** The headers one exact served path (deployment base included) gets. */
 export interface NodeHeaderRule {
@@ -23,20 +29,49 @@ export declare const NODE_ASTRO_ENTRY_FILE = "astro-entry.mjs";
 /** The header rules for this config, merged per path. */
 export declare const nodeHeaderRules: (config: ResolvedConfig) => NodeHeaderRule[];
 /**
- * The entry that replaces Astro's: it stamps the rules' headers on the
- * response, then hands the request to Astro's handler. `send` leaves a
- * Content-Type that is already set alone, so the registered media type wins.
+ * The configured redirects the wrapper answers, keyed by served path (the
+ * trailing slash trimmed), each to its `Location` and exact status.
+ */
+export type NodeRedirects = Record<string, [string, number]>;
+/**
+ * The configured 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.
+ */
+export declare const nodeRedirects: (project: BlumeProject) => NodeRedirects;
+/** 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 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.
+ *
+ * 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
+ * client directory either way, and `send` decodes and normalizes the path —
+ * so `/docs/blume-assets/a.sv%67`, `/blume-assets/a.svg`, and
+ * `/docs//x/../blume-assets/a.svg` are all the same SVG. The comparison
+ * ignores case, as a case-insensitive disk and `send`'s MIME lookup do.
  *
  * It keeps Astro's contract — the `handler`, `options`, and `startServer`
  * exports `astro preview` and a middleware-mode host import — and its
  * autostart: Astro's entry is imported with autostart off (the env var is read
  * when that module evaluates, so the import has to be dynamic), and the
- * wrapper starts the server itself with its listener in front of Astro's.
+ * wrapper starts the server itself, taking over its request listener so a
+ * redirect is answered before Astro sees the request.
  */
-export declare const nodeEntryWrapper: (rules: readonly NodeHeaderRule[]) => string;
+export declare const nodeEntryWrapper: (rules: readonly NodeHeaderRule[], options?: NodeEntryOptions) => string;
 /**
- * Put the header 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) leaves Astro's entry alone.
+ * 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.
  */
 export declare const wrapNodeEntry: (project: BlumeProject, log: BuildLog) => Promise<void>;

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

@@ -1,6 +1,31 @@
-import type { DeployPlatform, RedirectFile } from "./types.ts";
-/** `_redirects`, the format Netlify and Cloudflare Pages/Workers read. */
+import type { BlumeProject } from "../../core/project-graph.ts";
+import type { BuildLog, DeployPlatform, RedirectFile } from "./types.ts";
+/**
+ * `_redirects`, the format Netlify and Cloudflare Pages/Workers read, in the
+ * form both accept: a static build for Cloudflare, or for no named host.
+ */
 export declare const REDIRECTS_FILE: RedirectFile;
+/**
+ * `_redirects` for a `netlify()` static build, every rule forced (`301!`).
+ * Astro writes a redirect page at each `from` (`dist/old/index.html`), and
+ * Netlify serves a file that exists ahead of an unforced rule, so without the
+ * flag that page would answer with a 200 instead of the redirect.
+ */
+export declare const NETLIFY_REDIRECTS_FILE: RedirectFile;
+/** The Frameworks API config, once the build surfaced it to the project root. */
+export declare const NETLIFY_CONFIG_FILE: string;
+/**
+ * Carry the static header rules into a server build. A static `netlify()`
+ * build gets them from `_headers` (see `deploy/artifacts.ts`), but a server
+ * build's header rules go in the Frameworks API config the adapter writes
+ * (`.netlify/v1/config.json`, beside its own `Cache-Control` rule for
+ * `/_astro/*`), which follows the same rules as `netlify.toml`'s
+ * `[[headers]]`: the charset on the raw Markdown and text files, the homepage
+ * `Link` header, the discovery files' media types and CORS header, and the
+ * sandbox on downloaded SVGs, which Netlify serves from the publish directory
+ * as static files, so the prerendered endpoint's own headers never ship.
+ */
+export declare const emitNetlifyHeaders: (project: BlumeProject, log: BuildLog) => 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

@@ -2,10 +2,11 @@ import type { DeployPlatform } from "./types.ts";
 /**
  * A self-hosted Node server. The standalone server in `dist/server` serves
  * `dist/client` through its own static handler, which has no `_headers` or
- * `_redirects` support — redirects are answered at request time from the
- * Astro config, and a header file written there would be inert. The headers
- * the discovery files need come from a wrapper around the server entry
- * instead (`deploy/node-headers.ts`). No platform env to detect: the site URL
- * has to be configured.
+ * `_redirects` support, so a file written there would be inert. A wrapper
+ * around the server entry (`deploy/node-headers.ts`) sets the headers the
+ * 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.
  */
 export declare const nodePlatform: DeployPlatform;

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

@@ -89,6 +89,13 @@ export interface DeployPlatform {
     kind: DeployAdapterKind;
     /** Whether a server build honors `Accept: text/markdown` at the content URLs. */
     negotiatesMarkdown: boolean;
+    /**
+     * The host CLI command that deploys a preview, for a platform whose
+     * `@astrojs/*` adapter has no local preview server: Astro's `preview`
+     * throws for its server build, so `blume preview` points here instead. Null
+     * when the adapter can preview a server build locally, or there is none.
+     */
+    previewDeploy: string | null;
     /**
      * Whether the platform applies a `_headers` file to the static assets it
      * serves, per output mode.
@@ -96,6 +103,14 @@ export interface DeployPlatform {
     readsHeaderFiles: Record<DeployOutput, boolean>;
     /** The redirect files a static build writes, beside the manifest. */
     redirectFiles: RedirectFile[];
+    /**
+     * 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`,
+     * 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. */

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

@@ -26,7 +26,8 @@ export declare const emitVercelNegotiation: (project: BlumeProject, log: BuildLo
  * `@vercel/nft` dependency trace is rooted there too, and tracing from the
  * hidden runtime silently drops the function's chunks and `node_modules`.
  * Static assets are served from the tree's `static/` half, so the deploy
- * artifacts are written there; headers arrive through the routing config
- * rather than a `_headers` file, which Vercel never reads.
+ * artifacts are written there; headers (the discovery files', the sandbox on
+ * downloaded SVGs) arrive through the routing config rather than a
+ * `_headers` file, which Vercel never reads.
  */
 export declare const vercelPlatform: DeployPlatform;