blume 1.7.2 → 2.0.0

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

@@ -0,0 +1,131 @@
+import type { ContentSource, SourceContext } from "./types.ts";
+interface NotionRichText {
+    plain_text: string;
+    href?: string | null;
+    annotations?: {
+        bold?: boolean;
+        italic?: boolean;
+        code?: boolean;
+        strikethrough?: boolean;
+    };
+}
+interface NotionProperty {
+    type: string;
+    title?: NotionRichText[];
+    rich_text?: NotionRichText[];
+    select?: {
+        name: string;
+    } | null;
+    status?: {
+        name: string;
+    } | null;
+    number?: number | null;
+}
+interface NotionPage {
+    id: string;
+    properties: Record<string, NotionProperty>;
+    last_edited_time?: string;
+}
+/** The per-type payload a block carries under the key matching its `type`. */
+interface NotionBlockPayload {
+    caption?: NotionRichText[];
+    checked?: boolean;
+    external?: {
+        url: string;
+    };
+    file?: {
+        url: string;
+    };
+    language?: string;
+    rich_text?: NotionRichText[];
+}
+interface NotionBlock {
+    id: string;
+    type: string;
+    has_children?: boolean;
+    [key: string]: NotionBlockPayload | boolean | string | undefined;
+}
+interface NotionList<T> {
+    results: T[];
+    has_more: boolean;
+    next_cursor: string | null;
+}
+/**
+ * The slice of `@notionhq/client` (v5+) this adapter relies on, so it's
+ * mockable. Since API version 2025-09-03 a database's rows live in a data
+ * source: `databases.retrieve` names the data sources and
+ * `dataSources.query` pages through one of them.
+ */
+export interface NotionClientLike {
+    databases: {
+        retrieve: (args: {
+            database_id: string;
+        }) => Promise<{
+            data_sources: {
+                id: string;
+                name: string;
+            }[];
+        }>;
+    };
+    dataSources: {
+        query: (args: {
+            data_source_id: string;
+            start_cursor?: string;
+        }) => Promise<NotionList<NotionPage>>;
+    };
+    blocks: {
+        children: {
+            list: (args: {
+                block_id: string;
+                start_cursor?: string;
+            }) => Promise<NotionList<NotionBlock>>;
+        };
+    };
+}
+/** Notion property names mapped onto Blume meta. */
+export interface NotionPropertyMap {
+    /** Title property name; defaults to the database's `title`-typed property. */
+    title?: string;
+    /** Description property (rich_text); default `Description`. */
+    description?: string;
+    /** Slug property (rich_text); default `Slug`, else the slugified title. */
+    slug?: string;
+    /** Status property (select/status); default `Status`. */
+    status?: string;
+    /** Sidebar order property (number); default `Order`. */
+    order?: string;
+}
+export interface NotionSourceOptions {
+    name: string;
+    prefix?: string;
+    /** The Notion database id. */
+    database: string;
+    /**
+     * Maximum concurrent Notion API requests. Notion allows an average of 3
+     * requests per second per integration, so a large database must pace its
+     * block-tree fan-out or every request 429s. Default 3.
+     */
+    concurrency?: number;
+    /** Integration token; defaults to `NOTION_TOKEN`. */
+    token?: string;
+    properties?: NotionPropertyMap;
+    /**
+     * The `Status` property is treated as a publish signal: any value other than
+     * this maps to `draft: true`. Defaults to `Published`; pages without a
+     * Status/select property are always imported as published.
+     */
+    publishedValue?: string;
+    /** Opt-in dev polling interval (seconds); omit to freeze for the session. */
+    pollInterval?: number;
+    /** Injected for tests; otherwise built from `@notionhq/client`. */
+    client?: NotionClientLike;
+    /** Injected for tests; used to download images. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Notion content source. Maps a database to a collection: each page becomes an
+ * entry, its properties become frontmatter, and its block tree is converted to
+ * MDX with Blume components. Images are materialized so signed URLs don't rot.
+ */
+export declare const notionSource: (options: NotionSourceOptions, ctx?: SourceContext) => ContentSource;
+export {};

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

@@ -0,0 +1,46 @@
+import type { ResolvedI18nConfig, ResolvedVersionsConfig } from "../schema.ts";
+import type { ContentSource, SourceContext } from "./types.ts";
+/** Options for the built-in Obsidian vault source. */
+export interface ObsidianSourceOptions {
+    /**
+     * The project's default content type (`content.defaultType`), which a note
+     * without a `type` resolves to when {@link typeFrontmatterKeys} are picked.
+     */
+    defaultType?: string;
+    /** Vault folder names to skip at any depth, in addition to dot-folders. */
+    exclude?: string[];
+    /**
+     * Frontmatter keys the project declares site-wide beyond Blume's page meta
+     * (`frontmatter.extend`). Any other Obsidian property is dropped when a note
+     * is lowered, since the strict meta schema would reject it and fail the
+     * build.
+     */
+    frontmatterKeys?: readonly string[];
+    /** The project's i18n config, when locale directories place vault notes. */
+    i18n?: ResolvedI18nConfig;
+    /** Stable source name; namespaces ids and diagnostics. */
+    name: string;
+    /** Namespaces the source's routes under `/<prefix>/`; e.g. `vault`. */
+    prefix?: string;
+    /**
+     * Frontmatter keys each content type declares (`content.types.<type>.frontmatter`),
+     * keyed by type. A note keeps only the keys of its own type — the meta parse
+     * merges only that type's schema, so a key another type declares would still
+     * reach the strict page schema and fail.
+     */
+    typeFrontmatterKeys?: Readonly<Record<string, readonly string[]>>;
+    /** Vault directory, absolute or relative to `projectRoot`. */
+    vault: string;
+    /** The project's versions config, when snapshot directories hold notes. */
+    versions?: ResolvedVersionsConfig;
+}
+/**
+ * The built-in Obsidian vault source: read a vault directly — no export step,
+ * no generated files in the user's repo — lowering Obsidian's dialect to
+ * Blume-ready Markdown at load time.
+ *
+ * Staged, since the body is rewritten before Blume sees it; `sourcePath` still
+ * points at the note, so diagnostics and relative image checks name the real
+ * file. A wikilink Blume cannot resolve degrades rather than failing the build.
+ */
+export declare const obsidianSource: (options: ObsidianSourceOptions, ctx: SourceContext) => ContentSource;

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

@@ -0,0 +1,39 @@
+import type { JsonObject } from "./json.ts";
+import type { RemoteFieldMap } from "./remote.ts";
+import type { ContentSource, SourceContext } from "./types.ts";
+export interface PayloadSourceOptions {
+    name: string;
+    prefix?: string;
+    /** The Payload app's origin (`https://cms.acme.dev`); its REST API is at `/api`. */
+    url: string;
+    /** The collection slug whose documents become pages. */
+    collection: string;
+    /**
+     * The auth-enabled collection the API key belongs to; default `users`. It
+     * names the scheme in the `Authorization` header (`users API-Key <key>`).
+     */
+    authCollection?: string;
+    /** Relationship depth to populate; default `1`, enough for upload URLs. */
+    depth?: number;
+    /**
+     * Field paths mapping a document onto Blume meta + body. Defaults:
+     * `title`, `description`, `slug`, `content`, `updatedAt`.
+     */
+    fields?: RemoteFieldMap;
+    /** Extra query parameters for the collection request (`where[...]`, `sort`). */
+    params?: Record<string, string>;
+    /** Serializers for `block`/`inlineBlock` nodes, keyed by `blockType`. */
+    serializers?: Record<string, (fields: JsonObject) => string>;
+    /** API key; defaults to `PAYLOAD_API_KEY`. */
+    token?: string;
+    /** Opt-in dev polling interval (seconds); omit to freeze for the session. */
+    pollInterval?: number;
+    /** Injected for tests; defaults to the global `fetch`. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Payload content source. Pages through a collection's REST endpoint, maps
+ * each document's fields to frontmatter, and lowers its Lexical body to
+ * Markdown. Published documents only, unless `--preview` asks for drafts.
+ */
+export declare const payloadSource: (options: PayloadSourceOptions, ctx?: SourceContext) => ContentSource;

package/dist/types/core/sources/portable-text.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A field value on a Portable Text node: the arbitrary JSON the CMS query
+ * returned (custom blocks carry whatever fields the studio schema defines).
+ * Spans and mark defs appear as members so the block's typed fields conform
+ * to its index signature.
+ */
+export type PortableTextValue = string | number | boolean | null | undefined | PortableTextSpan | PortableTextMarkDef | PortableTextValue[] | {
+    [key: string]: PortableTextValue;
+};
+/** A single Portable Text node (block, image, or a custom type). */
+export interface PortableTextBlock {
+    _type: string;
+    _key?: string;
+    style?: string;
+    listItem?: string;
+    level?: number;
+    children?: PortableTextSpan[];
+    markDefs?: PortableTextMarkDef[];
+    [key: string]: PortableTextValue;
+}
+interface PortableTextSpan {
+    _type: string;
+    text?: string;
+    marks?: string[];
+}
+interface PortableTextMarkDef {
+    _key: string;
+    _type: string;
+    href?: string;
+}
+export interface PortableTextOptions {
+    /** Resolve an image block to a URL (the adapter knows project/dataset). */
+    imageUrl?: (block: PortableTextBlock) => string | null;
+    /**
+     * Custom block-type serializers, keyed by `_type`; return Markdown or MDX.
+     * Setting any writes the source's entries as MDX.
+     */
+    serializers?: Record<string, (block: PortableTextBlock) => string>;
+}
+/** Serialize a Portable Text array into a Markdown string. */
+export declare const portableTextToMarkdown: (blocks: PortableTextBlock[], options?: PortableTextOptions) => string;
+export {};

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

@@ -0,0 +1,23 @@
+import type { PageRecord } from "../types.ts";
+import type { ContentSource } from "./types.ts";
+/** The subset of a scanned project the entry reader needs. */
+export interface EntryReadContext {
+    /** The instantiated sources, keyed for `read()` lookups. */
+    sources?: ContentSource[];
+}
+/**
+ * Read an entry's raw body text without assuming a filesystem path. Prefers the
+ * body captured at scan time (staged sources), then the owning source's lazy
+ * `read()`, then the back-compat `sourcePath` (any local file). Returns `""` when an
+ * entry can't be resolved, so callers degrade gracefully.
+ */
+export declare const readEntryText: (ctx: EntryReadContext, page: PageRecord) => Promise<string>;
+/**
+ * Read an entry's raw body with `<include>` statements expanded — what search
+ * indexing, the `.md`/`.mdx` mirrors, and llms-full.txt should see, matching
+ * the spliced content the rendered page shows. Filesystem entries only
+ * (includes resolve as filesystem paths); everything else passes through
+ * verbatim. Expansion errors were already surfaced as scan diagnostics, so
+ * unresolvable statements simply stay verbatim here.
+ */
+export declare const readExpandedEntryText: (ctx: EntryReadContext, page: PageRecord) => Promise<string>;

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

@@ -0,0 +1,74 @@
+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 {
+    /** 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 staged-source scaffolding a CMS adapter shares: a snapshot cache under
+ * `.blume/cache/<source>/` (or a name-derived dir when constructed directly
+ * as a custom source, without a context), cache-first dev loads, offline
+ * fallback, `read()` for raw export, and an opt-in polling `watch`.
+ */
+export declare const remoteSource: (options: RemoteSourceOptions, ctx?: SourceContext) => ContentSource;
+/** The frontmatter a CMS document maps to. */
+export interface RemoteFrontmatter {
+    description?: string;
+    draft?: boolean;
+    title?: string;
+}
+/**
+ * A staged entry: Markdown body plus the frontmatter it was mapped from,
+ * written as `.mdx` when the body carries serializer output (see
+ * `writesMdx`).
+ */
+export declare const stagedEntry: (slug: string, data: RemoteFrontmatter, markdown: string, lastModified: string | undefined, format?: "md" | "mdx") => SourceEntry;
+/** How a source calls its CMS: the API's auth headers and an injectable fetch. */
+export interface RestClient {
+    /** Injected for tests; defaults to the global `fetch`. */
+    fetchImpl?: typeof fetch;
+    headers?: Record<string, string>;
+}
+/**
+ * How long one CMS request may take before the source gives up on it. A
+ * stalled CMS would otherwise hold `scanProject()` — and every `blume dev`
+ * rescan — indefinitely, and the cache fallback can only kick in once the
+ * request rejects.
+ */
+export declare const REMOTE_TIMEOUT_MS = 30000;
+/**
+ * GET a JSON endpoint. A non-2xx response is an error naming the status, so
+ * the source's cache fallback reports why (`401 Unauthorized`) instead of a
+ * parse failure on an error body; a request past {@link REMOTE_TIMEOUT_MS}
+ * rejects with a `TimeoutError`.
+ */
+export declare const fetchJson: (url: string, client: RestClient) => Promise<JsonValue>;
+/** A query string from the fixed params plus a user's extra ones. */
+export declare const queryString: (params: Record<string, string | undefined>) => string;
+/** Field paths mapping a CMS document onto Blume meta + body. */
+export interface RemoteFieldMap {
+    /** Field holding the renderable body (rich text, or a Markdown string). */
+    body?: string;
+    /** Field holding the page description. */
+    description?: string;
+    /** Field holding the last-modified ISO date. */
+    lastModified?: string;
+    /** Field holding the route slug. */
+    slug?: string;
+    /** Field holding the page title. */
+    title?: string;
+}
+/**
+ * Map a document to a staged entry. The slug falls back to the document's id
+ * when the slug field is missing or slugifies to nothing (pure punctuation),
+ * so distinct documents never collapse onto one `untitled.md`; a slashed
+ * slug keeps its segments. A string body is Markdown and passes through as
+ * `.md`; 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

@@ -0,0 +1,19 @@
+import type { ResolvedConfig } from "../schema.ts";
+import type { ProjectContext } from "../types.ts";
+import type { ContentSource } from "./types.ts";
+export { resolveDocsCollection, resolveSourceRoot, sourcesOfKind, } from "./collection.ts";
+export type { DocsCollection } from "./collection.ts";
+/** Runtime knobs for a scan: dev/build mode, preview, and cache refresh. */
+export interface SourceRuntime {
+    mode: "dev" | "build";
+    preview?: boolean;
+    refresh?: boolean;
+}
+/**
+ * Build the ordered list of content sources for a project. The config schema
+ * already desugared the zero-config shorthand into a single `filesystem()`
+ * descriptor, so every project has at least one entry here. A Blume-rendered
+ * OpenAPI reference contributes an internal staged source that lowers each
+ * operation into a real content page (routing/nav/search/OG).
+ */
+export declare const resolveSources: (config: ResolvedConfig, context: ProjectContext, runtime: SourceRuntime) => ContentSource[];

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

@@ -0,0 +1,43 @@
+import type { PortableTextBlock } from "./portable-text.ts";
+import type { ContentSource, SourceContext } from "./types.ts";
+/** The slice of `@sanity/client` this adapter relies on (so it's mockable). */
+export interface SanityClientLike {
+    fetch: <T = unknown>(query: string) => Promise<T>;
+}
+/** Field paths mapping a Sanity document onto Blume meta + body. */
+export interface SanityFieldMap {
+    /** Frontmatter title; default `title`. */
+    title?: string;
+    /** Frontmatter description; default `description`. */
+    description?: string;
+    /** Route slug (dot path); default `slug.current`. */
+    slug?: string;
+    /** Portable Text body field; default `body`. */
+    body?: string;
+    /** Last-modified ISO date; default `_updatedAt`. */
+    lastModified?: string;
+}
+export interface SanitySourceOptions {
+    name: string;
+    prefix?: string;
+    projectId: string;
+    dataset: string;
+    /** Sanity API version (a date); default `2024-01-01`. */
+    apiVersion?: string;
+    /** GROQ query selecting the documents to import. */
+    query: string;
+    fields?: SanityFieldMap;
+    /** Custom Portable Text block serializers, keyed by `_type`. */
+    serializers?: Record<string, (block: PortableTextBlock) => string>;
+    /** Read token for private datasets; defaults to `SANITY_TOKEN`. */
+    token?: string;
+    /** Opt-in dev polling interval (seconds); omit to freeze for the session. */
+    pollInterval?: number;
+    /** Injected for tests; otherwise built from `@sanity/client`. */
+    client?: SanityClientLike;
+}
+/**
+ * Sanity content source. Runs a GROQ query, maps each document's fields to Blume
+ * frontmatter and its Portable Text body to Markdown, and stages the result.
+ */
+export declare const sanitySource: (options: SanitySourceOptions, ctx?: SourceContext) => ContentSource;

package/dist/types/core/sources/strapi-blocks.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Strapi's Rich text (Blocks) field → Markdown. Covers every block the
+ * editor emits: paragraphs, headings, lists (nested), quotes, code, images,
+ * and links with the text modifiers.
+ */
+import type { JsonValue } from "./json.ts";
+export interface StrapiBlocksOptions {
+    /** The Strapi origin a relative upload URL (`/uploads/x.png`) resolves against. */
+    baseUrl?: string;
+}
+/** Serialize a Blocks field value (an array of block nodes) to Markdown. */
+export declare const strapiBlocksToMarkdown: (blocks: JsonValue, options?: StrapiBlocksOptions) => string;

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

@@ -0,0 +1,33 @@
+import type { RemoteFieldMap } from "./remote.ts";
+import type { ContentSource, SourceContext } from "./types.ts";
+export interface StrapiSourceOptions {
+    name: string;
+    prefix?: string;
+    /** The Strapi origin (`https://cms.acme.dev`); its REST API is at `/api`. */
+    url: string;
+    /** The content type's plural API id (`articles`). */
+    contentType: string;
+    /** Locale code to fetch, for a localized content type. */
+    locale?: string;
+    /** The `populate` parameter; default `*`, which fills media and relations. */
+    populate?: string;
+    /**
+     * Field paths mapping an entry onto Blume meta + body. Defaults:
+     * `title`, `description`, `slug`, `content`, `updatedAt`.
+     */
+    fields?: RemoteFieldMap;
+    /** Extra query parameters for the request (`filters[...]`, `sort`). */
+    params?: Record<string, string>;
+    /** API token; defaults to `STRAPI_API_TOKEN`. */
+    token?: string;
+    /** Opt-in dev polling interval (seconds); omit to freeze for the session. */
+    pollInterval?: number;
+    /** Injected for tests; defaults to the global `fetch`. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Strapi content source. Pages through a content type's REST endpoint, maps
+ * each entry's fields to frontmatter, and lowers its Blocks body to
+ * Markdown. Published entries only, unless `--preview` asks for drafts.
+ */
+export declare const strapiSource: (options: StrapiSourceOptions, ctx?: SourceContext) => ContentSource;

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

@@ -113,6 +113,12 @@ export interface ContentSource {
     readonly staged: boolean;
     /** Optional route prefix; the source's routes namespace under `/<prefix>/`. */
     readonly prefix?: string;
+    /**
+     * True for a source whose entries exist in one language and can never be
+     * translated (GitHub Releases). Its pages render without a language
+     * switcher, since every other locale would only repeat the same text.
+     */
+    readonly monolingual?: 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)
@@ -137,6 +143,7 @@ export interface ContentSource {
 /** Context passed to `normalizeEntry`, describing the owning source. */
 export interface NormalizeContext {
     source: {
+        monolingual?: boolean;
         name: string;
         prefix?: string;
         staged: boolean;

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

@@ -0,0 +1,45 @@
+import type { WatchListener } from "node:fs";
+/**
+ * Directory segments that are never authored content: VCS, dependency trees,
+ * Blume's own generated project and build output, and framework/deploy caches.
+ * Both the content scan and the dev watcher skip these unconditionally, on top
+ * of the user's `content.exclude`.
+ *
+ * The scan needs them because a broadly-scoped `content.root` — `"."` or an app
+ * dir that also holds `node_modules`/`dist`, the common shape when migrating a
+ * docs app that lives at the repo or app root — would otherwise glob thousands
+ * of stray markdown files out of dependencies and build artifacts. `content.root`
+ * defaults to `docs/` where this rarely bites, but any wider root hits it.
+ *
+ * The watcher needs them because a recursive `fs.watch` rooted at the project
+ * also sees Blume's own `.blume/` output, which the dev server rewrites on every
+ * render (e.g. `.blume/.astro/data-store.json`). Left unfiltered, each such write
+ * re-triggers a rescan + runtime regeneration whose writes land back under
+ * `.blume/` and fire the watcher again: a self-sustaining loop that stalls page
+ * renders and floods the console. `fs.watch` has no ignore option, so we filter
+ * by the changed path in the callback.
+ */
+export declare const BLUME_IGNORE_DIRS: string[];
+/**
+ * Baseline scan-ignore globs applied to every filesystem source, unioned with
+ * the user's `content.exclude`. Kept in sync with the watcher via the shared
+ * {@link BLUME_IGNORE_DIRS} so `load()` and `watch()` never disagree on what is
+ * content. `**\/<dir>/**` matches the directory at the content root or nested.
+ */
+export declare const baselineScanIgnore: () => string[];
+/**
+ * Alias retained for the dev watcher's call site and its tests; the watcher and
+ * 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. */
+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`
+ * 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/text-width.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The longest prefix of `text` that renders within `max` display columns
+ * without cutting inside a grapheme cluster. Columns are `string-width`'s: a
+ * fullwidth or wide character counts 2, a combining mark 0, everything else 1
+ * — the same measure `blume audit` grades titles and meta descriptions with,
+ * so text cut here stays inside the audit's thresholds for every script, not
+ * just Latin. Grapheme segmentation is rule-based (UAX #29), so unlike word
+ * segmentation it does not drift across ICU builds, and it can never split a
+ * surrogate pair or halve an emoji sequence.
+ */
+export declare const columnsPrefix: (text: string, max: number) => string;

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

@@ -147,6 +147,11 @@ export interface PageRecord {
      * checks skip these.
      */
     fallback?: boolean;
+    /**
+     * True for pages from a source that publishes one language only (GitHub
+     * Releases): they render without a language switcher.
+     */
+    monolingual?: boolean;
     /**
      * Content-relative path with the leading locale directory stripped, used for
      * sidebar grouping so the locale dir is not surfaced as a nav group. Equals
@@ -208,6 +213,11 @@ export type NavNode = {
      */
     display: SidebarDisplay;
     icon?: string;
+    /**
+     * The group row's link: an explicit-config group's `root`, or the
+     * generated folder's index page route. Absent when there is no page at
+     * the group's own path, so the row never links to a 404.
+     */
     route?: string;
     /**
      * The group's URL path (its folder route prefix), even when the folder
@@ -289,6 +299,13 @@ export interface Navigation {
     featured: FeaturedLink[];
     /** Repo URL for the header link, or null when hidden (`navigation.repo`). */
     repoUrl?: string | null;
+    /**
+     * Where the header's brand link points in this locale: `logo.href` moved
+     * into the locale's prefix when the locale serves that route, else left on
+     * the default route (a custom home page exists only at `/`). Set on i18n
+     * locale trees.
+     */
+    brandHref?: string;
 }
 /** The full content graph: the source of truth for generated modules. */
 export interface ContentGraph {
@@ -373,6 +390,8 @@ export interface RouteManifestEntry {
     versionAlternates: VersionAlternate[];
     /** True when this route renders fallback content for a missing translation. */
     fallback?: boolean;
+    /** True when the page's source publishes one language only (no switcher). */
+    monolingual?: boolean;
     /** Resolved "last updated" ISO date, when the feature is enabled. */
     lastModified?: string;
 }
@@ -382,7 +401,7 @@ export interface BlumeManifest {
     blumeVersion: string;
     projectRoot: string;
     contentRoot: string;
-    output: ResolvedConfig["deployment"]["output"];
+    output: ResolvedConfig["deployment"]["options"]["output"];
     routes: RouteManifestEntry[];
 }
 export {};

package/dist/types/core/unrecognized-keys.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Zod's own wording for unknown keys no removed-key hint covers, appended to
+ * a hint so an unrelated typo isn't silently dropped from the diagnostic
+ * beside it. Shared by every config object that names a removed field's
+ * replacement (the root config, `ai.ask`, `openapi()`/`asyncapi()`, …).
+ */
+export declare const unrecognizedKeysMessage: (keys: string[]) => string;