blume 2.0.2 → 2.1.0

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
@@ -22,28 +37,26 @@ export declare const codeSpan: (code: string) => string;
  * 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, and whitespace the first runs put in front of a block turns it into
- * an indented code block. Apply it to the joined text of a paragraph,
- * heading, quote, or list item — never to code.
+ * 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 guardBlockStart: (text: 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.
- */
-export declare const renderInline: (text: string, marks: InlineMarks) => 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. */

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[];

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/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

@@ -297,7 +297,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/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/headers.d.ts

@@ -65,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

@@ -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

@@ -28,6 +28,11 @@ export declare const emitCloudflareDeployConfig: (context: ProjectContext) => Pr
  * built config instead, and is left alone.
  */
 export declare const nameCloudflareWorker: (project: BlumeProject, log: BuildLog) => Promise<void>;
+/**
+ * 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 Workers and Pages. A server build emits the Worker into
  * `dist/server` and serves `dist/client` through the ASSETS binding, which

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

@@ -103,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

@@ -20,6 +20,12 @@ export declare const checkVercelFunctionBundles: (outputDir: string, root: strin
  * root it was shown.
  */
 export declare const emitVercelNegotiation: (project: BlumeProject, log: BuildLog) => Promise<void>;
+/**
+ * Route the pattern redirects (`/beta/:slug*`) in the adapter's Build Output
+ * config: Astro's `redirects` carry only the exact ones, since it can't
+ * prerender a pattern's pages, so the adapter never sees these.
+ */
+export declare const emitVercelPatternRedirects: (project: BlumeProject, log: BuildLog) => Promise<void>;
 /**
  * Vercel. A server build's Build Output tree lands at `.vercel/output` — at
  * the project root, because the adapter is handed that root up front: its

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

@@ -1,11 +1,17 @@
+import type { RouteSet } from "../core/locale-links.ts";
+import type { BlumeProject } from "../core/project-graph.ts";
 import type { ResolvedConfig } from "../core/schema.ts";
 import type { VercelHeader } from "./headers.ts";
+import type { VercelRoute } from "./vercel-negotiation.ts";
 /**
  * Platform redirect files for a static build. Astro already emits redirect HTML
  * (meta-refresh) pages for static output, but that's a soft client redirect.
  * These give the host a real HTTP 3xx: Netlify/Cloudflare read `_redirects`,
  * Vercel reads `vercel.json`, and `blume-redirects.json` is a structured
- * manifest for anything else (Apache/nginx rules, an edge worker).
+ * manifest for anything else (Apache/nginx rules, an edge worker). A pattern
+ * redirect (`/beta/:slug*`) gets no redirect page, since Astro can't
+ * prerender one for paths it doesn't know; each host file carries it in that
+ * host's syntax (see `core/redirect-patterns.ts`).
  */
 type Redirect = ResolvedConfig["redirects"][number];
 /**
@@ -15,34 +21,44 @@ type Redirect = ResolvedConfig["redirects"][number];
  * - `from` gains only `basePath`. Astro builds the match pattern with
  *   `deployment.base` already applied (`getPattern(segments, config.base)`), so
  *   adding it here would serve the redirect at `{base}{base}/from`.
- * - `to` gains the full `{deployment.base}{basePath}` stack. Astro resolves a
- *   destination that matches a known route by regenerating it from that route's
- *   segments, which carry no base — and passes an unmatched destination through
- *   verbatim. Neither path prepends `base`, so a root-relative `to` escapes the
- *   base entirely (withastro/astro#7774, still the behavior in Astro 7).
+ * - `to` gains the full `{deployment.base}{basePath}` stack, or the deployment
+ *   base alone for a public file (see {@link baseRedirectTarget}). Astro
+ *   resolves a destination that matches a known route by regenerating it from
+ *   that route's segments, which carry no base — and passes an unmatched
+ *   destination through verbatim. Neither path prepends `base`, so a
+ *   root-relative `to` escapes the base entirely (withastro/astro#7774, still
+ *   the behavior in Astro 7).
  *
- * Both sides are authored as if mounted at root; external `to` URLs pass
- * through. Idempotent, so a hand-written base isn't doubled.
+ * Both sides are authored as if mounted at root; `routes` (the served page
+ * routes, carrying `basePath`) tell a dotted page route like `/releases/v1.2`
+ * from a file. Idempotent, so a hand-written base isn't doubled.
  */
-export declare const applyBaseToAstroRedirects: (redirects: Redirect[], basePath: string, deployBase: string) => Redirect[];
+export declare const applyBaseToAstroRedirects: (redirects: Redirect[], basePath: string, deployBase: string, routes: RouteSet) => Redirect[];
 /**
  * Base a redirect for the host platform files below. Unlike Astro's config,
- * these are matched against the real served URL, so both sides carry the full
- * `{deployment.base}{basePath}` stack.
+ * these are matched against the real served URL, so `from` carries the full
+ * `{deployment.base}{basePath}` stack, and so does `to` unless it names a
+ * public file (see {@link baseRedirectTarget}).
  */
-export declare const applyBaseToPlatformRedirects: (redirects: Redirect[], basePath: string, deployBase: string) => Redirect[];
+export declare const applyBaseToPlatformRedirects: (redirects: Redirect[], basePath: string, deployBase: string, routes: RouteSet) => Redirect[];
 /**
  * The configured redirects as the host platform matches them, via
- * {@link applyBaseToPlatformRedirects}. The one basing every consumer must
- * share: the emitted redirect files and the Cloudflare worker-first redirect
- * exemptions both compare these paths against real served URLs.
+ * {@link applyBaseToPlatformRedirects}, exact paths ahead of patterns: hosts
+ * try rules in order, and an exact redirect wins over a pattern that also
+ * covers its path. The one basing every consumer must share: the emitted
+ * redirect files and the server wrappers all compare these paths against
+ * real served URLs.
  */
-export declare const platformRedirects: (config: ResolvedConfig) => Redirect[];
+export declare const platformRedirects: (project: {
+    config: ResolvedConfig;
+    manifest: Pick<BlumeProject["manifest"], "routes">;
+}) => Redirect[];
 /**
- * `_redirects` text (Netlify + Cloudflare Pages): `from to status` per line.
- * `force` appends Netlify's `!` to each status (`301!`), so the rule wins over
- * the redirect page Astro writes at `from`; Cloudflare, which always applies
- * its rules first, rejects a line carrying it.
+ * `_redirects` text (Netlify + Cloudflare Pages): `from to status` per line,
+ * a pattern as `:placeholder`s and a `*` splat the destination reads as
+ * `:splat`. `force` appends Netlify's `!` to each status (`301!`), so the rule
+ * wins over the redirect page Astro writes at `from`; Cloudflare, which always
+ * applies its rules first, rejects a line carrying it.
  */
 export declare const buildNetlifyRedirects: (redirects: Redirect[], force?: boolean) => string;
 /**
@@ -50,9 +66,32 @@ export declare const buildNetlifyRedirects: (redirects: Redirect[], force?: bool
  * header rules are given (see `buildVercelHeaders`). Uses `statusCode` (Vercel's
  * alternative to the boolean `permanent`) so the configured code ships exactly:
  * `permanent` would silently coerce a 301 to 308 and a 302 to 307, diverging
- * from the `_redirects` file, which preserves exact codes.
+ * from the `_redirects` file, which preserves exact codes. A `source` is a
+ * `path-to-regexp` pattern, so each literal run of a `from` path is escaped:
+ * unescaped, `/c++-guide` fails the whole config and `/faq(old)` never
+ * matches. A pattern's captures are `path-to-regexp` params.
  */
 export declare const buildVercelConfig: (redirects: Redirect[], headers?: readonly VercelHeader[]) => string;
-/** Structured manifest for hosts that need manual wiring. */
+/**
+ * The pattern redirects as `_redirects` entries, for the `redirects` of a
+ * Netlify server build's Frameworks API config (see
+ * {@link buildNetlifyRedirects} for the syntax).
+ */
+export declare const netlifyPatternRedirects: (redirects: Redirect[]) => {
+    from: string;
+    status: number;
+    to: string;
+}[];
+/**
+ * The pattern redirects as Build Output API routes, for a Vercel server
+ * build: the adapter routes only the exact redirects Astro's config carries.
+ * Each matches the served path, a trailing slash optional, and fills its
+ * `Location` from numbered captures, as the adapter's own redirect routes do.
+ */
+export declare const vercelPatternRoutes: (redirects: Redirect[]) => VercelRoute[];
+/**
+ * Structured manifest for hosts that need manual wiring. A pattern stays as
+ * configured (`/beta/:slug*`), for the rule it becomes to be written by hand.
+ */
 export declare const buildRedirectManifest: (redirects: Redirect[]) => string;
 export {};

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

@@ -108,3 +108,12 @@ export declare const buildNegotiationRoutes: (routePaths: readonly string[], hom
  * `handle: "filesystem"` marker to anchor the splice.
  */
 export declare const injectNegotiationRoutes: (configText: string, routePaths: readonly string[], homeLinkHeader?: string | null, contentTypeOverrides?: Record<string, string>, homeTokens?: number, notFound?: NotFoundVariants, corsPaths?: readonly string[], svgAssets?: boolean) => string | null;
+/**
+ * Splice routes for the pattern redirects (see `vercelPatternRoutes`) into a
+ * Build Output `config.json`, in the main phase just ahead of
+ * `handle: "filesystem"`: after the exact redirects the adapter puts first,
+ * so an exact path still wins. A second pass replaces its own routes. Returns
+ * the updated JSON text, or `null` when there is nowhere safe to splice: an
+ * unparsable config, no `routes` array, or no `handle: "filesystem"` marker.
+ */
+export declare const injectRedirectRoutes: (configText: string, redirectRoutes: readonly VercelRoute[]) => string | null;

package/dist/types/markdown/code-title.d.ts

@@ -7,7 +7,20 @@
  *   language label.
  * - the `lineNumbers` keyword (```ts file.ts lineNumbers) becomes
  *   `data-line-numbers`; the theme renders a counter-driven line-number gutter.
+ * - the `wrap` keyword becomes `data-wrap`: this block's long lines wrap
+ *   instead of scrolling, as `markdown.code.wrap` does for every block.
+ * - the `expandable` keyword becomes `data-expandable` on a block of
+ *   {@link EXPANDABLE_MIN_LINES} lines or more: the theme shows its first
+ *   {@link EXPANDABLE_VISIBLE_LINES} lines, and the page script adds a toggle
+ *   that shows the rest in full. A shorter block renders as it is.
  */
+/** The lines a collapsed `expandable` block shows. */
+export declare const EXPANDABLE_VISIBLE_LINES = 10;
+/**
+ * The lines a block needs before `expandable` collapses it: a few more than it
+ * shows, so the toggle never hides a line or two behind a click.
+ */
+export declare const EXPANDABLE_MIN_LINES = 16;
 /** The slice of Shiki's transformer `this` context Blume reads. */
 interface CodeMetaContext {
     options: {
@@ -15,6 +28,8 @@ interface CodeMetaContext {
             __raw?: string;
         };
     };
+    /** The block's code, as highlighted. */
+    source?: string;
 }
 /** The `<pre>` hast node a Shiki `pre` hook receives. */
 interface PreNode {
@@ -27,6 +42,8 @@ export interface CodeTitleTransformer {
 }
 /** The title a fence's meta string promotes to `data-title`, if any. */
 export declare const parseCodeTitle: (raw: string | undefined) => string | undefined;
+/** How many lines a block's code runs to, a trailing newline aside. */
+export declare const lineCount: (source?: string) => number;
 /** Build the transformer. Runs after Shiki's built-in `data-language` hook. */
 export declare const codeTitleTransformer: () => CodeTitleTransformer;
 export {};

package/dist/types/markdown/directives.d.ts

@@ -0,0 +1,62 @@
+import type { MdastNode, MdastVisitorContext } from "./mdast.ts";
+export interface DirectiveNode extends MdastNode {
+    attributes?: Record<string, string | null | undefined> | null;
+    children?: MdastNode[] | null;
+    name: string;
+    position?: {
+        start?: {
+            offset?: number;
+        };
+        end?: {
+            offset?: number;
+        };
+    };
+}
+/**
+ * The visitor-context slice the directive visitors use. `source` is the page
+ * the directive offsets index into; without it the literal fallback rebuilds
+ * a directive from its node instead. `parent` walks up to an enclosing
+ * container directive, which renders the directives inside it itself.
+ */
+interface DirectiveVisitorContext extends MdastVisitorContext {
+    parent?: (node: MdastNode) => MdastNode | undefined;
+    source?: string;
+}
+/** Directive names that map directly onto a Callout type. */
+export declare const CALLOUT_TYPES: ReadonlySet<string>;
+/** Friendly aliases for the canonical Callout types. */
+interface CalloutAliases {
+    [alias: string]: string;
+}
+export declare const CALLOUT_ALIASES: Readonly<CalloutAliases>;
+/** Resolve a directive name to a Callout type, or `null` if it is not one. */
+export declare const calloutTypeFor: (name: string) => string | null;
+/**
+ * A text or leaf directive exactly as the author wrote it. The slice by
+ * offsets is the exact text — `[label]` and `{attrs}` included — and is
+ * trusted only when it opens with the directive's own marker and name;
+ * content an `<include>` spliced in carries no offsets into this page, so it
+ * is rebuilt from the node instead.
+ */
+export declare const directiveSource: (node: DirectiveNode, marker: string, source: string) => string;
+/**
+ * Satteri MDAST plugin for directives. Container directives (`:::note`,
+ * `:::warning`, `:::tip`, …) map onto Blume's `<Callout>` component, and any
+ * other container renders its body between its literal fence lines (see
+ * {@link renderContainer}).
+ *
+ * Blume handles no text (`:name`) or leaf (`::name`) directives, and prose is
+ * full of text that parses as one — `16:9`, `10:30am`, `og:image`,
+ * `pets:read` — so both render as the literal source the author wrote instead
+ * of vanishing.
+ */
+export declare const directiveToCalloutPlugin: () => {
+    containerDirective(node: DirectiveNode, ctx: DirectiveVisitorContext): void;
+    leafDirective: (node: DirectiveNode, ctx: DirectiveVisitorContext) => void;
+    name: string;
+    options: {
+        position: boolean;
+    };
+    textDirective: (node: DirectiveNode, ctx: DirectiveVisitorContext) => void;
+};
+export {};

package/dist/types/markdown/features.d.ts

@@ -8,8 +8,9 @@ export declare const MARKDOWN_FEATURES: {
 };
 /**
  * The `.mdx` feature set: Markdown's plus `:::` directives (→ `<Callout>`) and
- * block-only math — `singleDollarTextMath: false` keeps a bare `$` (currency,
- * shell, code) as literal text and only parses `$$…$$`.
+ * math — `singleDollarTextMath: false` keeps a bare `$` (currency, shell,
+ * code) as literal text and only parses `$$…$$`, as a block on its own lines
+ * or inline within a sentence.
  */
 export declare const MDX_FEATURES: {
     directive: true;
@@ -19,3 +20,24 @@ export declare const MDX_FEATURES: {
     subscript: true;
     superscript: true;
 };
+/**
+ * The feature sets for a page body, once its front matter is off. Astro reads
+ * a page's front matter itself and hands the renderer the body alone, and the
+ * search extractor strips it first too — so front matter parsing is off here:
+ * left on, a body that opens with a `---` rule read everything up to the next
+ * `---` line as front matter and dropped it from the page.
+ */
+export declare const MARKDOWN_BODY_FEATURES: {
+    frontmatter: false;
+    subscript: true;
+    superscript: true;
+};
+export declare const MDX_BODY_FEATURES: {
+    frontmatter: false;
+    directive: true;
+    math: {
+        singleDollarTextMath: false;
+    };
+    subscript: true;
+    superscript: true;
+};