blume 2.1.3 → 2.2.1

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

@@ -41,10 +41,29 @@ export declare const unloadablePathDiagnostic: (path: string, file: string) => D
  * 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 ATTRIBUTE: string;
+/** A heading's trailing `{#id}` marker, where its text holds one. */
+export interface TrailingCurlyMarker {
+    /** Whether the braces also set classes or attributes (`{ #id .wide }`). */
+    attributes: boolean;
+    id: string;
+    /** Where the marker starts in the text. */
+    index: number;
+    /** The braces as written. */
+    marker: string;
+}
+/**
+ * The `{#id}` marker a heading's text ends with: one of the spellings
+ * `BARE_CURLY_MARKER` matches, or an attribute list that sets an id among
+ * other attributes (see `HEADING_ATTRIBUTE_LIST`).
+ */
+export declare const trailingCurlyMarker: (text: string) => TrailingCurlyMarker | 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`. */
+/** A heading whose trailing `{#id}` marker is unescaped — see `trailingCurlyMarker`. */
 export interface CurlyMarker {
+    /** Whether the braces also set classes or attributes (`{ #id .wide }`). */
+    attributes: boolean;
     id: string;
     /** 1-based line of the heading (a setext heading's first text line) in the body. */
     line: number;
@@ -61,10 +80,10 @@ export interface HeadingSite {
 /** Everything one walk over a body yields for the anchor index. */
 export interface BodyScan {
     /**
-     * Raw HTML element ids (`<a id="…">`) outside headings, fences, inline
-     * code, comments, and `<Prompt>` regions — fragment-link targets that
-     * `blume validate` accepts alongside heading slugs. Deduplicated, in
-     * document order.
+     * Raw HTML element ids (`<a id="…">`) and `<a name="…">` names outside
+     * headings, fences, inline code, comments, and `<Prompt>` regions —
+     * fragment-link targets that `blume validate` accepts alongside heading
+     * slugs. Deduplicated, in document order.
      */
     anchors: string[];
     /** Headings whose trailing `{#id}` marker is unescaped, for `.mdx` pages. */
@@ -83,10 +102,77 @@ export interface BodyScan {
  */
 export declare const scanBody: (body: string) => BodyScan;
 export declare const extractHeadings: (body: string) => Heading[];
-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[];
+/**
+ * Rewrite the target of every image embed on one line with `rewrite`, which
+ * gets the target as the renderer reads it (see `readDestination`) and
+ * returns the new one, or `null` to leave it as written. Inline code is
+ * skipped: matches run on a copy with code spans blanked, and replacements
+ * splice into the real line by index, which the same-length mask keeps in
+ * step. A rewritten target is written back in the form its destination took.
+ */
+export declare const rewriteImageTargets: (line: string, rewrite: (target: string) => string | null) => string;
+/** A string `href` or `src` on an element, as {@link rewriteElementUrls} reads it. */
+export interface ElementUrl {
+    attribute: string;
+    /** The element's name as written: `img`, `a`, `Card`. */
+    tag: string;
+    value: string;
+}
+/**
+ * Whether an element URL is one `blume validate` reads as a link (see
+ * `ELEMENT_HREF` and `ELEMENT_SRC`): a media element's `src`, or an `<a>`'s or
+ * a component's `href`. Only these name a file the build publishes from
+ * beside the page.
+ */
+export declare const isLinkElementUrl: (url: ElementUrl) => boolean;
+/**
+ * Rewrite every `<Card img="…">` value in `text` (outside code) with
+ * `rewrite`, which returns the new value or `null` to leave one as written.
+ * The include expander rebases a partial's values with it and the
+ * content-asset rewriter points them at their served URL, exactly as both
+ * treat image embeds, so a card's image resolves like `![](./cover.png)`.
+ */
+export declare const rewriteCardImages: (text: string, rewrite: (target: string) => string | null) => string;
+/**
+ * Rewrite every element's string `href` or `src` in `text` (outside code)
+ * with `rewrite`, which returns the new value or `null` to leave one as
+ * written. The include expander rebases a partial's files with it, the
+ * content-asset rewriter points them at their served URL, and the render
+ * plugins rewrite raw HTML with it.
+ */
+export declare const rewriteElementUrls: (text: string, rewrite: (url: ElementUrl) => string | null) => string;
+/**
+ * Rewrite the target of every Markdown link in `text` (outside code) with
+ * `rewrite`, which gets the target as the renderer reads it and returns the
+ * new one, or `null` to leave it as written: inline links (an image embed is
+ * no link; see {@link rewriteImageTargets}), links whose label wraps onto
+ * later lines, and link-reference definitions (`[spec]: ./spec.pdf`). Each
+ * rewritten target is written back in the form its destination took.
+ */
+export declare const rewriteLinkTargets: (text: string, rewrite: (target: string) => string | null) => string;
+/** A link-reference definition, as {@link linkDefinitions} reads one. */
+export interface LinkDefinition {
+    /** The label as CommonMark matches it: case-folded, spaces collapsed. */
+    key: string;
+    /** The definition on a line of its own, out of any container. */
+    text: string;
+}
+/**
+ * Every link-reference definition in `text` (`[label]: /url "Title"`,
+ * outside code; footnotes aren't links), in order, the first of each label
+ * only, since that's the one that renders. A definition is read from its own
+ * line: its destination and any title there, and nothing else, since a line
+ * with more after them is text.
+ */
+export declare const linkDefinitions: (text: string) => LinkDefinition[];
+/**
+ * Extract link targets from a markdown body for later validation, recording the
+ * 1-based line/column of each target. Skips fenced code blocks, inline code,
+ * and — given the page's `format` — comments, none of which render a link.
+ * `lineOffset` shifts every recorded line: the body is frontmatter-stripped, so
+ * diagnostics that point into the raw file must add the stripped block's height.
+ */
+export declare const extractLinks: (body: string, lineOffset?: number, format?: "md" | "mdx") => 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
@@ -146,6 +232,12 @@ export interface EntryRoute extends Pick<EntryPlacement, "locales" | "version">
      * through {@link localizedRoute} for the route one locale publishes at.
      */
     logicalRoute: string;
+    /**
+     * The logical route an earlier Blume published the entry at, when it
+     * differs: a date-named file or folder (`12-05-2022`) lost its first number
+     * as an ordering prefix. Its old URL redirects to the new one.
+     */
+    formerLogicalRoute?: string;
     /** The prefixed, locale- and version-stripped nav path. */
     navPath: string;
     segments: string[];

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

@@ -65,6 +65,15 @@ export interface SourceEntry {
         includes: string[];
     };
 }
+/**
+ * A redirect a source asks for: from a route one of its pages used to have
+ * to the route it has now, both locale-stripped and without `basePath`, as
+ * the page routes its entries map to.
+ */
+export interface SourceRedirect {
+    from: string;
+    to: string;
+}
 /** The result of a single `ContentSource.load()` call. */
 export interface SourceLoadResult {
     entries: SourceEntry[];
@@ -78,6 +87,13 @@ export interface SourceLoadResult {
      * beneath user-authored meta files, which always win.
      */
     folderMeta?: Record<string, FolderMeta>;
+    /**
+     * Redirects from routes the source's pages moved off: the OpenAPI source
+     * keeps the URLs earlier releases gave operation pages working. Added to
+     * the config's `redirects` after them, skipping any whose `from` a page or
+     * a configured redirect already owns.
+     */
+    redirects?: SourceRedirect[];
 }
 /**
  * Per-source runtime context, handed to an adapter factory at construction so

package/dist/types/core/static-files.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Whether a root-relative path names a file the site serves outside its pages,
+ * as a static host answers it: a file in `public/`, a `public/` folder's
+ * `index.html` (`/demo` and `/demo/` for `public/demo/index.html`), or one of
+ * the files Blume generates (`generated`, base-less paths like `/llms.txt`;
+ * see `deploy/generated-files.ts`). `publicDir` is `null` when the project has
+ * no `public/` folder, which ships no files then. Paths come decoded, without
+ * `deployment.base`, which a host mounts `public/` under.
+ */
+export declare const staticFileResolver: (publicDir: string | null, generated?: Iterable<string>) => ((path: string) => boolean);

package/dist/types/core/static-host.d.ts

@@ -0,0 +1,42 @@
+/**
+ * What a static host does with the URLs `blume dev` and `blume preview`
+ * would otherwise answer on their own terms. Astro's `trailingSlash: "never"`
+ * has both 404 a slashed URL (`/guide/`), which every host answers: Vercel
+ * redirects it to `/guide`, and the others serve `guide/index.html`. And a
+ * folder of HTML shipped in `public/` (`public/demo/index.html`) is served at
+ * `/demo/`, `/demo` redirecting there, so the relative links inside it
+ * resolve against the folder; the dev server 404s both spellings, and Vite's
+ * preview serves only the slashless one.
+ */
+import type { IncomingMessage, Server } from "node:http";
+/** How to answer a request ahead of the server's own handlers. */
+export type HostAnswer = {
+    kind: "redirect";
+    location: string;
+    status: number;
+} | {
+    kind: "rewrite";
+    url: string;
+};
+/**
+ * Whether `public/<path>/index.html` exists: a folder of HTML the site ships
+ * as is. `path` is the decoded request path with `deployment.base` stripped.
+ */
+export declare const publicFolder: (publicDir: string) => (path: string) => boolean;
+/**
+ * How a static host answers a URL's trailing slash, or null to leave the
+ * request alone. A slashed URL redirects to its slashless page, its query
+ * kept, unless it names a public folder, which serves its `index.html`; a
+ * slashless public folder redirects to its slashed URL. `base` is the
+ * normalized `deployment.base`, which the URL carries and `public/` doesn't.
+ * The redirect is a `301`, a `308` for a method a `301` would turn into a
+ * `GET`, as Astro answers on a server-rendered route.
+ */
+export declare const trailingSlashAnswer: (request: Pick<IncomingMessage, "method" | "url">, base: string, isPublicFolder: (path: string) => boolean) => HostAnswer | null;
+/**
+ * Answer every request on `server` with `answer` first: a redirect is sent
+ * then and there, and a rewrite changes the URL the server's own handlers
+ * (Vite's middleware) then see. They're the request listeners the server
+ * already has, so this goes ahead of every middleware, Astro's included.
+ */
+export declare const answerRequestsFirst: (server: Server, answer: (request: IncomingMessage) => HostAnswer | null, headers?: Record<string, string>) => void;

package/dist/types/core/svg-images.d.ts

@@ -0,0 +1,26 @@
+import type { Diagnostic, PageRecord } from "./types.ts";
+/**
+ * Colocated SVGs Astro's image pipeline can't measure. Astro reads an image's
+ * size before it optimizes it, and for an SVG it looks for the `<svg>` tag in
+ * the file's first 1,000 bytes only, then needs a width and height or a
+ * viewBox on that tag. A draw.io export carries its whole diagram in a
+ * `content` attribute on the tag, which pushes the tag's end past that
+ * window, so one diagram fails the build (`NoImageMetadata`). Blume serves
+ * such an SVG as it is instead, from the endpoint that already serves content
+ * images to agents (`/blume-assets/content/…`), and warns about it
+ * (`BLUME_SVG_UNOPTIMIZED`). A browser draws an SVG at any size, so the
+ * only loss is the intrinsic `width`/`height` the optimized `<img>` carries.
+ */
+/** Whether the file at `path` is an SVG Astro can't read the size of. */
+export declare const isUnmeasurableSvg: (path: string) => Promise<boolean>;
+/**
+ * The URL an unmeasurable SVG is served at, unbased (the base links plugin
+ * mounts `deployment.base`), or null when `target` isn't a colocated image
+ * Astro can measure no size for.
+ */
+export declare const unmeasurableSvgUrl: (sourceDir: string, target: string, projectRoot: string) => Promise<string | null>;
+/**
+ * A warning for each image embed of a colocated SVG Astro can't measure, at
+ * the line that embeds it (in a partial, when an `<include>` brought it in).
+ */
+export declare const unmeasurableSvgDiagnostics: (pages: readonly PageRecord[]) => Promise<Diagnostic[]>;

package/dist/types/core/syntax-diagnostics.d.ts

@@ -0,0 +1,14 @@
+import type { SourceEntry } from "./sources/types.ts";
+import type { Diagnostic, PageRecord } from "./types.ts";
+/** The site's pages by the names a wiki link can call them (see {@link wikiKey}). */
+export type PageNameIndex = ReadonlyMap<string, readonly PageRecord[]>;
+/** Index pages by file name and title, for {@link syntaxDiagnostics}. */
+export declare const indexPageNames: (pages: readonly PageRecord[]) => PageNameIndex;
+/**
+ * Warn about syntax from other docs tools in an entry's body (see the module
+ * comment). `pages` are the site's pages by name, which a wiki link resolves
+ * against, preferring one in the entry's own `locale`. Lines point into the
+ * file the author wrote, a partial's own file for syntax an `<include>`
+ * brought in.
+ */
+export declare const syntaxDiagnostics: (entry: SourceEntry, sourceName: string, pages?: PageNameIndex, locale?: string) => Diagnostic[];

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

@@ -45,8 +45,13 @@ export interface Heading {
 }
 /** A link target discovered in page content, anchored to its source line. */
 export interface PageLink {
-    /** Raw link target as written, e.g. `./foo`, `/api#auth`, `https://x.dev`. */
+    /** Raw link target as written, e.g. `./foo`, `/api#auth`, `https://x.dev`.
+     * A Markdown destination is read as the renderer reads it: without its
+     * `<…>` brackets, and with backslash escapes resolved. */
     target: string;
+    /** Length of the target's text in the source, when escapes make it differ
+     * from `target`'s (`image\(1\).png` is read as `image(1).png`). */
+    sourceLength?: number;
     /** Set when the target was written as an image embed (`![alt](target)`) —
      * only those go through the image pipeline; a plain link to the same path
      * resolves as a site route. */
@@ -55,6 +60,11 @@ export interface PageLink {
      * 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;
+    /** The element, when the target is a media element's `src` (`img`,
+     * `source`, `video`, `audio`). It's `raw` too: the browser resolves it as
+     * written, unless it names a file beside the page, which the build
+     * publishes and points it at. */
+    src?: string;
     /** 1-based line number in the source file. */
     line: number;
     /** 1-based column of the target within the line. */
@@ -75,6 +85,25 @@ export interface ExampleUse {
     /** Absolute path of the included partial it was written in, if not the page. */
     file?: string;
 }
+/**
+ * A JSX element in an `.mdx` body whose props don't render as written (see
+ * `core/mdx-elements.ts`), located like a {@link PageLink}: an HTML element
+ * with a JavaScript event handler (`handler`), or a childless built-in given
+ * props it doesn't take (`prop`).
+ */
+export interface ElementUse {
+    /** 1-based column of the element's `<` within the line. */
+    column: number;
+    /** Absolute path of the included partial it was written in, if not the page. */
+    file?: string;
+    kind: "handler" | "prop";
+    /** 1-based line number in the source file. */
+    line: number;
+    /** The handler props, or the props the built-in doesn't take. */
+    props: string[];
+    /** The element's name as written (`button`, `Badge`). */
+    tag: string;
+}
 /**
  * Resolved project paths. Computed once per CLI invocation and threaded
  * through the core pipeline.
@@ -162,6 +191,12 @@ export interface PageRecord {
      * checks skip these.
      */
     fallback?: boolean;
+    /**
+     * The route an earlier Blume published the page at, when it differs from
+     * `route`: a date-named file or folder (`12-05-2022`) lost its first number
+     * as an ordering prefix. The scan redirects it to `route`.
+     */
+    formerRoute?: string;
     /**
      * True for pages from a source that publishes one language only (GitHub
      * Releases): they render without a language switcher.
@@ -202,6 +237,12 @@ export interface PageRecord {
     componentsUsed?: string[];
     /** The string `path` of each `<Component>` example in the body (`.mdx` only). */
     examplesUsed?: ExampleUse[];
+    /**
+     * Childless built-ins given props they don't take (`.mdx` only). Reported
+     * once the project's own components are known, since an override takes
+     * whatever props it declares.
+     */
+    unknownProps?: ElementUse[];
     /** 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/generated-files.d.ts

@@ -0,0 +1,41 @@
+import type { SkillArtifact } from "../ai/skills.ts";
+import type { BlumeProject } from "../core/project-graph.ts";
+import type { ResolvedConfig } from "../core/schema.ts";
+/** A generated `.well-known` discovery document: `null` content when it's off. */
+export interface WellKnownFile {
+    content: string | null;
+    label: string;
+    path: string;
+}
+/**
+ * The generated `.well-known` discovery documents — the Web Bot Auth signature
+ * directory, the RFC 9727 API catalog, and the AI catalog under both the
+ * ai-catalog spec's well-known URI and the ARD v0.91 one (see
+ * `ai/ai-catalog.ts`) — each with `null` content when its feature is off.
+ */
+export declare const wellKnownFiles: (config: ResolvedConfig, skills: readonly SkillArtifact[]) => WellKnownFile[];
+/**
+ * The files a build serves beside its pages that don't come from `public/`,
+ * as base-less root-relative paths: what `publishBuildArtifacts` writes once
+ * Astro is done (llms.txt, the sitemap, robots.txt, `agent-readability.json`,
+ * the `.well-known` discovery documents, the Agent Skills index, `skill.md`)
+ * and the generated endpoints at fixed paths (the RSS feeds, the JSON docs
+ * API and its OpenAPI description, the MCP discovery documents). Each is
+ * listed under the gate its writer reads, so a feature the config switches
+ * off drops its file here too: `blume validate` accepts a link to
+ * `/llms.txt` exactly when the build writes one.
+ *
+ * Read from the config alone, before a build: the skill archives a build
+ * publishes beside the index, and the platform files (`_redirects`,
+ * `_headers`, `vercel.json`), aren't listed. A page's Markdown copy
+ * (`/guide.md`) is its route's, and resolves through the page.
+ */
+export declare const generatedFilePaths: (project: BlumeProject) => string[];
+/**
+ * Whether a base-less path is a file the project's site serves beside its
+ * pages: one in `public/` (`/spec.pdf`, a folder's `index.html`) or one the
+ * build generates (`/llms.txt`). What `generateRuntime` and `blume doctor`
+ * check navigation entries against, beside the routes, as `blume validate`
+ * checks links.
+ */
+export declare const servedFiles: (project: BlumeProject) => ((path: string) => boolean);

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

@@ -41,15 +41,29 @@ export declare const applyBaseToAstroRedirects: (redirects: Redirect[], basePath
  * public file (see {@link baseRedirectTarget}).
  */
 export declare const applyBaseToPlatformRedirects: (redirects: Redirect[], basePath: string, deployBase: string, routes: RouteSet) => Redirect[];
+/**
+ * Whether `from` names a page's own `index.html` (`/guide/index.html` for the
+ * page `/guide`, `/index.html` for the root), a URL a migrated site may have
+ * linked. A static build writes the page there, and Astro writes a redirect
+ * page to `<from>/index.html`, which would need that file to be a folder:
+ * the build fails with `EISDIR`. Hosts serve the page at that URL anyway,
+ * unless a redirect rule answers it first. `pages` are the served page
+ * routes, which carry `basePath`, as `from` does.
+ */
+export declare const isPageIndexFile: (from: string, pages: RouteSet) => boolean;
 /**
  * Based `redirects`, each exact one that moves a page followed by the same
- * redirect for the page's Markdown copies: from a path no page is served at
- * to one a page is, `/old.md` goes to `/new.md` (and `.mdx` alike), where it
- * would otherwise 404 for an agent still reading the old URL. A pattern gets
- * none; one that carries its capture over (`/beta/:slug*` → `/v2/:slug*`)
- * already moves `/beta/guide.md` along. `pages` are the served page routes
- * (carrying `basePath`, not `deployment.base`), and `bases` the deployment
- * base each end carries: Astro's config leaves it off `from` (see
+ * redirect for the page's Markdown copies: from a path whose copies no page
+ * serves to one a page is served at, `/old.md` goes to `/new.md` (and `.mdx`
+ * alike), where it would otherwise 404 for an agent still reading the old
+ * URL. A served copy never gives way: `/index` names the root's copies, so
+ * `/index` → `/` moving them would turn the home page's `/index.md` into a
+ * redirect to itself. A pattern gets none; one that carries its capture over
+ * (`/beta/:slug*` → `/v2/:slug*`) already moves `/beta/guide.md` along. Nor
+ * does a redirect from an `.html` file (`/guide.html`, from a migrated site),
+ * which had no copy to move. `pages` are the served page routes (carrying
+ * `basePath`, not `deployment.base`), and `bases` the deployment base each
+ * end carries: Astro's config leaves it off `from` (see
  * {@link applyBaseToAstroRedirects}).
  */
 export declare const withMirrorRedirects: (redirects: Redirect[], pages: RouteSet, bases: {

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

@@ -2,9 +2,9 @@
  * Code-fence meta. A Shiki transformer reads the tokens after the language and
  * promotes them to attributes on the rendered `<pre>`:
  *
- * - a title — the first bare token (```ts blume.config.ts) or `title="..."` —
- *   becomes `data-title`; the theme's code header shows it, falling back to the
- *   language label.
+ * - a title — the bare words (```ts blume.config.ts, ```js Install the
+ *   client) or `title="..."` — becomes `data-title`; the theme's code header
+ *   shows it, falling back to the 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
@@ -24,6 +24,7 @@ export declare const EXPANDABLE_MIN_LINES = 16;
 /** The slice of Shiki's transformer `this` context Blume reads. */
 interface CodeMetaContext {
     options: {
+        lang?: string;
         meta?: {
             __raw?: string;
         };
@@ -40,8 +41,11 @@ export interface CodeTitleTransformer {
     name: string;
     pre: (this: CodeMetaContext, node: PreNode) => void;
 }
-/** The title a fence's meta string promotes to `data-title`, if any. */
-export declare const parseCodeTitle: (raw: string | undefined) => string | undefined;
+/**
+ * The title a fence's meta string promotes to `data-title`, if any. `lang` is
+ * the fence's language, which decides the other tools' keywords it drops.
+ */
+export declare const parseCodeTitle: (raw: string | undefined, lang?: string) => 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. */

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

@@ -31,6 +31,14 @@ interface CalloutAliases {
 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 node's phrasing children (a directive label's, a paragraph's) written
+ * back as inline Markdown, for a component prop that renders it — a callout
+ * title. Text, emphasis, strong, strikethrough, code, and links keep their
+ * formatting; anything else reads as its text (an image as nothing, raw HTML
+ * as its literal source), the way a flattened title always did.
+ */
+export declare const phrasingMarkdown: (parent: MdastNode) => string;
 /**
  * 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

package/dist/types/markdown/fence-language.d.ts

@@ -0,0 +1,51 @@
+/**
+ * A code fence's language, read the way authors coming from other docs tools
+ * write it. Shiki matches language ids exactly, so two common spellings used
+ * to fall back to plain text with only a console line:
+ *
+ * - a capitalized id (```` ```JSON ````, ```` ```Dockerfile ````): Shiki's ids
+ *   and aliases are all lowercase, so the id is lowercased when that names a
+ *   language and the spelling as written doesn't.
+ * - a line range glued to the id (```` ```js{2} ````, the VitePress and
+ *   VuePress form): the range moves into the fence meta, ahead of any meta
+ *   already there, where the line-highlight transformer reads it.
+ * - a line range glued to a bracketed title (```` ```ts [file.ts]{2} ````,
+ *   the Docus form): a space splits it off, so the title is the bracketed
+ *   word alone and the range stays a range.
+ *
+ * Every other fence keeps its language and meta exactly as written.
+ */
+import type { MdastNode } from "./mdast.ts";
+/** Whether Shiki highlights `lang` as written: a bundled id, alias, or plain. */
+export declare const isKnownLanguage: (lang: string) => boolean;
+/** A fence's language and meta, after {@link normalizeFence}. */
+export interface Fence {
+    lang: string;
+    meta: string | null;
+}
+/**
+ * The language and meta a fence means, or null when it means what it says.
+ * A range glued to the language moves into the meta and one glued to a
+ * bracketed title splits off it, then a capitalized language that only names
+ * a known language in lowercase is lowercased.
+ */
+export declare const normalizeFence: (lang: string | null | undefined, meta: string | null | undefined) => Fence | null;
+/** The code node slice the plugin reads. */
+interface CodeNode extends MdastNode {
+    lang?: string | null;
+    meta?: string | null;
+}
+/** The visitor context slice the plugin writes through. */
+interface FenceContext {
+    setProperty: (node: CodeNode, key: "lang" | "meta", value: string | null) => void;
+}
+/**
+ * Satteri MDAST plugin applying {@link normalizeFence} to every fence. It runs
+ * before the plugins that read a fence's language (`package-install`, `ts2js`,
+ * mermaid) and before Shiki, so all of them see the normalized fence.
+ */
+export declare const fenceLanguagePlugin: () => {
+    code(node: CodeNode, ctx: FenceContext): void;
+    name: string;
+};
+export {};

package/dist/types/markdown/fence-meta.d.ts

@@ -19,5 +19,10 @@ export declare const metaTokens: (meta: string | null | undefined) => string[];
  * a block title.
  */
 export declare const RESERVED_META_KEYWORDS: ReadonlySet<string>;
+export declare const RUST_META_KEYWORDS: ReadonlySet<string>;
+/** The fence languages rustdoc's and mdBook's keywords apply to. */
+export declare const RUST_LANGUAGES: ReadonlySet<string>;
+/** Whether `token` is another tool's keyword in a fence of language `lang`. */
+export declare const isForeignKeyword: (token: string, lang: string | null | undefined) => boolean;
 /** A Shiki `{1,3-5}` line-range token. */
 export declare const isLineRange: (token: string) => boolean;

package/dist/types/markdown/github-alerts.d.ts

@@ -0,0 +1,35 @@
+import type { MdastNode, MdastVisitorContext } from "./mdast.ts";
+/**
+ * The callout each GitHub alert renders as. `IMPORTANT` has no callout of its
+ * own and reads as a note (`:::important` does too), and `CAUTION` — GitHub's
+ * red "risks or negative outcomes" alert — as danger.
+ */
+export declare const ALERT_CALLOUTS: ReadonlyMap<string, string>;
+/** An alert marker as written (`[!NOTE]`) and the callout it renders as. */
+export interface AlertMarker {
+    callout: string;
+    marker: string;
+}
+/** The alert marker a quote's first text opens with, if any. */
+export declare const alertMarkerOf: (text: string) => AlertMarker | undefined;
+/** The visitor-context slice the alert visitor uses. */
+interface AlertVisitorContext extends MdastVisitorContext {
+    parent?: (node: MdastNode) => MdastNode | undefined;
+    source?: string;
+}
+/**
+ * Satteri MDAST plugin for GitHub alerts in `.mdx`: a quote whose first line
+ * is `[!NOTE]`, `[!TIP]`, `[!IMPORTANT]`, `[!WARNING]`, or `[!CAUTION]`
+ * renders as the matching `<Callout>` (see {@link ALERT_CALLOUTS}), as on
+ * GitHub. An alert quoted inside another stays a quote, as GitHub leaves it.
+ * `.md` pages render no components, so their alerts stay quotes, which
+ * `blume check` warns about (`core/alert-diagnostics.ts`).
+ */
+export declare const githubAlertsPlugin: () => {
+    blockquote(node: MdastNode, ctx: AlertVisitorContext): void;
+    name: string;
+    options: {
+        position: boolean;
+    };
+};
+export {};

package/dist/types/openapi/asyncapi.d.ts

@@ -1,4 +1,4 @@
-import type { ApiOperationRef, ApiTagRef } from "./model.ts";
+import type { ApiOperationRef, CollectedOperations } from "./model.ts";
 /**
  * Blume's own AsyncAPI model — the second front-end of the API reference
  * pipeline. Specs are normalized to AsyncAPI 3.x at parse time (see
@@ -108,10 +108,11 @@ export declare const applyAsyncApiTraits: (document: AsyncApiDocument) => AsyncA
  * see plain channel/operation objects, trait-free.
  */
 export declare const normalizeAsyncApiDocument: (document: AsyncApiDocument) => AsyncApiDocument;
-/** The route-mapped operations, ordered tags, and skip warnings of one document. */
-export interface AsyncApiOperationCatalog {
-    operations: ApiOperationRef[];
-    tags: ApiTagRef[];
+/**
+ * The route-mapped operations, ordered tags, moved routes, and skip warnings
+ * of one document.
+ */
+export interface AsyncApiOperationCatalog extends CollectedOperations {
     warnings: string[];
 }
 /**

package/dist/types/openapi/checks.d.ts

@@ -1,3 +1,4 @@
+import type { JsonValue } from "../core/adapter.ts";
 import type { ApiDocument } from "./model.ts";
 /**
  * Targeted checks for spec mistakes that would otherwise render silently
@@ -14,14 +15,18 @@ export interface SpecIssue {
     message: string;
     suggestion: string;
 }
-/**
- * How a warning names an operation: `GET /pets`, or a webhook by its name
- * (`Webhook "newPet" (POST)`), since a webhook has no path.
- */
-export declare const operationLabel: (name: string, method: string, webhook: boolean) => string;
 /**
  * Check a parsed document for the mistakes above, and for the OpenAPI 3.2
  * features Blume doesn't render yet. `$ref` path items are skipped: the
  * extractor already reports them as missing from the reference.
  */
 export declare const specIssues: (document: ApiDocument) => SpecIssue[];
+/**
+ * A spec written as OpenAPI 3.1 or later that still uses `nullable`, which
+ * 3.1 removed for `type: [T, "null"]`. Read as written (before Blume
+ * upgrades a 3.0 spec, which rewrites `nullable` itself), since that's the
+ * document the author edits. Blume still renders those values as nullable,
+ * but validators and SDK generators that follow 3.1 read them as never
+ * null. One warning per spec, naming the first few places.
+ */
+export declare const nullableIssues: (document: JsonValue) => SpecIssue[];