blume 2.2.2 → 2.2.3

package/dist/cli/{chunk-4zxh25hc.js → chunk-zgca0vxs.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   locateMdxFailure
-} from "./chunk-zxd5jrgx.js";
+} from "./chunk-gc7knd2s.js";
 
 // src/cli/build-failure.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -154,4 +154,4 @@ var buildFailureLocator = (project) => (file, failure) => {
 export { astroBuildDiagnostics, buildFailureLocator };
 
 //# debugId=A5E390AFCF69E70164756E2164756E21
-//# sourceMappingURL=chunk-4zxh25hc.js.map
+//# sourceMappingURL=chunk-zgca0vxs.js.map

package/dist/cli/{chunk-c5bjxq8v.js → chunk-zj6bcx0n.js}

@@ -7,7 +7,7 @@ import {
   packageSrc,
   registry,
   findItem
-} from "./chunk-9h8mh2tk.js";
+} from "./chunk-5f96yq2c.js";
 
 // src/cli/commands/add.ts
 import { existsSync } from "node:fs";
@@ -96,4 +96,4 @@ export {
 };
 
 //# debugId=B640E77C94BA0A0364756E2164756E21
-//# sourceMappingURL=chunk-c5bjxq8v.js.map
+//# sourceMappingURL=chunk-zj6bcx0n.js.map

package/dist/cli/{chunk-1ch3ct3r.js → chunk-zjfwzrvd.js}

@@ -8,28 +8,28 @@ import {
 import {
   commandsFor,
   detectProjectPackageManager
-} from "./chunk-r5nm9w0c.js";
+} from "./chunk-hwjspffr.js";
 import"./chunk-zccbjcj0.js";
-import"./chunk-hktq4j5r.js";
-import"./chunk-zxd5jrgx.js";
-import"./chunk-b680sv30.js";
-import"./chunk-k45sq16q.js";
-import"./chunk-rtvgmg2j.js";
-import"./chunk-j4nfgn2j.js";
+import"./chunk-pxp1y6yz.js";
+import"./chunk-gc7knd2s.js";
+import"./chunk-2f6btenb.js";
+import"./chunk-0xyedh7k.js";
+import"./chunk-8h2t2vyj.js";
+import"./chunk-znwhf37a.js";
 import"./chunk-jq5n4avg.js";
-import"./chunk-487b95qy.js";
-import"./chunk-9h8mh2tk.js";
+import"./chunk-88q28zav.js";
+import"./chunk-5f96yq2c.js";
 import {
   updatePackageScripts,
   isEjectedProject
-} from "./chunk-e1n41w9m.js";
+} from "./chunk-1ay3hzn0.js";
 import {
   eject
-} from "./chunk-40vk8kgf.js";
+} from "./chunk-p4fe7tax.js";
 import {
   refuseIfDevRunning
-} from "./chunk-h0qwdbem.js";
-import"./chunk-q1wwrxzw.js";
+} from "./chunk-r5ajrw1g.js";
+import"./chunk-rc2qk3qx.js";
 
 // src/cli/commands/eject.ts
 import { defineCommand } from "citty";
@@ -95,4 +95,4 @@ export {
 };
 
 //# debugId=9A7F310B3D4EBEE364756E2164756E21
-//# sourceMappingURL=chunk-1ch3ct3r.js.map
+//# sourceMappingURL=chunk-zjfwzrvd.js.map

package/dist/cli/{chunk-j4nfgn2j.js → chunk-znwhf37a.js}

@@ -390,4 +390,4 @@ var analyzeComponentOverrides = (source, filePath) => {
 export { emptyComponentOverrides, ComponentOverridesError, analyzeComponentOverrides };
 
 //# debugId=59653B23465A56F364756E2164756E21
-//# sourceMappingURL=chunk-j4nfgn2j.js.map
+//# sourceMappingURL=chunk-znwhf37a.js.map

package/dist/cli/index.js

@@ -725,24 +725,24 @@ var main = defineCommand({
     version: getBlumeVersion()
   },
   subCommands: {
-    add: lazyCommand(commandMeta.add, () => import("./chunk-c5bjxq8v.js"), "addCommand"),
-    audit: lazyCommand(commandMeta.audit, () => import("./chunk-2ssh60qh.js"), "auditCommand"),
-    build: lazyCommand(commandMeta.build, () => import("./chunk-nqna8dzp.js"), "buildCommand"),
-    check: lazyCommand(commandMeta.check, () => import("./chunk-beb0z983.js"), "checkCommand"),
-    dev: lazyCommand(commandMeta.dev, () => import("./chunk-x60e15st.js"), "devCommand"),
-    doctor: lazyCommand(commandMeta.doctor, () => import("./chunk-hn3g2b89.js"), "doctorCommand"),
-    eject: lazyCommand(commandMeta.eject, () => import("./chunk-1ch3ct3r.js"), "ejectCommand"),
-    eval: lazyCommand(commandMeta.eval, () => import("./chunk-9jqmq5hv.js"), "evalCommand"),
-    init: lazyCommand(commandMeta.init, () => import("./chunk-etckvbrh.js"), "initCommand"),
-    "mcp-stdio": lazyCommand(commandMeta["mcp-stdio"], () => import("./chunk-qcyxkj44.js"), "mcpStdioCommand"),
-    migrate: lazyCommand(commandMeta.migrate, () => import("./chunk-yg8ckc3g.js"), "migrateCommand"),
-    preview: lazyCommand(commandMeta.preview, () => import("./chunk-69rjf786.js"), "previewCommand"),
-    skill: lazyCommand(commandMeta.skill, () => import("./chunk-p834rkcn.js"), "skillCommand"),
-    sync: lazyCommand(commandMeta.sync, () => import("./chunk-080mfch6.js"), "syncCommand"),
-    translate: lazyCommand(commandMeta.translate, () => import("./chunk-f260jdrn.js"), "translateCommand"),
-    upgrade: lazyCommand(commandMeta.upgrade, () => import("./chunk-ydqzkhjn.js"), "upgradeCommand"),
-    validate: lazyCommand(commandMeta.validate, () => import("./chunk-ppa6mg4d.js"), "validateCommand"),
-    version: lazyCommand(commandMeta.version, () => import("./chunk-x7bh6d9j.js"), "versionCommand")
+    add: lazyCommand(commandMeta.add, () => import("./chunk-zj6bcx0n.js"), "addCommand"),
+    audit: lazyCommand(commandMeta.audit, () => import("./chunk-982qfeny.js"), "auditCommand"),
+    build: lazyCommand(commandMeta.build, () => import("./chunk-xkx216rd.js"), "buildCommand"),
+    check: lazyCommand(commandMeta.check, () => import("./chunk-b664x65a.js"), "checkCommand"),
+    dev: lazyCommand(commandMeta.dev, () => import("./chunk-5xq12jz7.js"), "devCommand"),
+    doctor: lazyCommand(commandMeta.doctor, () => import("./chunk-yrmw5n2b.js"), "doctorCommand"),
+    eject: lazyCommand(commandMeta.eject, () => import("./chunk-zjfwzrvd.js"), "ejectCommand"),
+    eval: lazyCommand(commandMeta.eval, () => import("./chunk-akj2p7k1.js"), "evalCommand"),
+    init: lazyCommand(commandMeta.init, () => import("./chunk-xv8nkt56.js"), "initCommand"),
+    "mcp-stdio": lazyCommand(commandMeta["mcp-stdio"], () => import("./chunk-qax1aekz.js"), "mcpStdioCommand"),
+    migrate: lazyCommand(commandMeta.migrate, () => import("./chunk-88zkpg89.js"), "migrateCommand"),
+    preview: lazyCommand(commandMeta.preview, () => import("./chunk-ry2ymbxf.js"), "previewCommand"),
+    skill: lazyCommand(commandMeta.skill, () => import("./chunk-g62vnvaw.js"), "skillCommand"),
+    sync: lazyCommand(commandMeta.sync, () => import("./chunk-0wt5amrk.js"), "syncCommand"),
+    translate: lazyCommand(commandMeta.translate, () => import("./chunk-0ynr0fr7.js"), "translateCommand"),
+    upgrade: lazyCommand(commandMeta.upgrade, () => import("./chunk-x0jqyq1g.js"), "upgradeCommand"),
+    validate: lazyCommand(commandMeta.validate, () => import("./chunk-8fm3b4vm.js"), "validateCommand"),
+    version: lazyCommand(commandMeta.version, () => import("./chunk-6xag1c83.js"), "versionCommand")
   }
 });
 loadEnvFiles(process.cwd());

package/dist/types/ai/ask-context.d.ts

@@ -52,6 +52,14 @@ export interface AskRetrievalOptions {
      */
     maxResults?: number;
 }
+/**
+ * An excerpt's heading: the Markdown link the model cites the page with. A
+ * bracket or backslash in the title, or whitespace or a parenthesis in the
+ * route, would break the link, and a `%` in the route would read back as an
+ * escape (`read_page` decodes them), so those are escaped; the rest of the
+ * route stays as the reader sees it (`/ja/ポイント`).
+ */
+export declare const excerptHeading: (doc: Pick<OramaDoc, "route" | "title">) => string;
 /**
  * Excerpt the region of `content` most relevant to `query`, not just its head.
  *

package/dist/types/ai/link-text.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A title as Markdown link text. An unescaped bracket in it — `[Beta] Webhooks`
+ * — closes or nests the text early, and the line stops being a link.
+ */
+export declare const linkText: (title: string) => string;

package/dist/types/ai/relative-links.d.ts

@@ -6,7 +6,9 @@ import type { BlumeProject } from "../core/project-graph.ts";
  * link lands on `/install`; the rendered page rewrites it to the route it
  * means (`markdown/relative-links.ts`), and the Markdown an agent reads gets
  * the same rewrite from the same resolver (`resolveRelativeHref`), so both
- * point at one page. Root-relative links (`[x](/guide)`,
+ * point at one page. A raw HTML `<a href>` ships as written, so a relative
+ * one lands where the browser takes it from the page's URL
+ * (`resolveRawRelativeHref`). Root-relative links (`[x](/guide)`,
  * `<Card href="/guide">`, `![logo](/logo.png)`) get what the rendered page
  * gives them too (`markdown/base-links.ts`,
  * `components/content/base-href.ts`): a page link the `deployment.base` +
@@ -18,18 +20,36 @@ import type { BlumeProject } from "../core/project-graph.ts";
  * (`resolveRootFileHref`). Inline links, images, component
  * `href`s, and reference definitions are rewritten; fenced and inline code,
  * relative images and asset links, and external URLs are left as written.
+ * The assistant's snapshot takes the links that name a page by its path or
+ * file alone, as the routes it keys pages by (`assistant`).
  */
 /** The page a Markdown text was written for. */
 export interface LinkedPage {
+    /**
+     * A staged page's path under its staging dir, which its links resolve from
+     * when it has no `sourcePath` (a remote or CMS source).
+     */
+    entryId?: string;
     route: string;
     sourcePath?: string;
 }
 /** Rewrite a page's relative page links to the routes they mean. */
 export type RelativeLinkRewriter = (text: string, page: LinkedPage) => string;
+/** Who reads the rewritten links. */
+export interface RelativeLinkOptions {
+    /**
+     * The assistant's snapshot, rather than a page an agent fetches by URL.
+     * Only a link that names a page by its relative path or its content file
+     * changes, to the route the snapshot keys that page by: without the
+     * `deployment.base`, since the chat panel mounts every link it renders
+     * under it, and a locale's fallback copy as the page it renders, since the
+     * snapshot holds that page instead. Root page links and images stay as
+     * written.
+     */
+    assistant?: boolean;
+}
 /**
- * Build the rewriter for a project: the file → route lookup a `.md`/`.mdx`
- * link resolves through is built once. A file shared by every locale
- * publishes once per locale, and the default locale's route stands for it;
- * fallback copies render another locale's file, so they never stand for one.
+ * Build the rewriter for a project, for an agent reading a page by URL or,
+ * with `assistant`, for the assistant's snapshot.
  */
-export declare const relativeLinkRewriter: (project: BlumeProject) => RelativeLinkRewriter;
+export declare const relativeLinkRewriter: (project: BlumeProject, options?: RelativeLinkOptions) => RelativeLinkRewriter;

package/dist/types/core/config-input.d.ts

@@ -981,6 +981,12 @@ export interface OgPaletteConfig {
 }
 /** Per-page Open Graph image generation. */
 export interface OgConfig {
+    /**
+     * Default social image for pages without their own `seo.image`, in place of
+     * the generated card (which then defaults off): one path or URL, or one per
+     * locale, like any localizable label.
+     */
+    image?: string | Record<string, string>;
     /**
      * Card subtitle. Defaults to the site description; a string overrides it,
      * `false` renders the card without one.
@@ -1097,6 +1103,31 @@ export interface SoftwareConfig {
 }
 /** Discoverability: OG images, feeds, sitemap, robots, and structured data. */
 export interface SeoConfig {
+    /**
+     * Structured-data entities shared with a parent site (`example.com/docs`),
+     * referenced by absolute `@id` instead of defined again.
+     */
+    jsonLd?: {
+        /** The WebSite's `@id`, which every page names as `isPartOf`. */
+        websiteId?: string;
+        /** The Organization's `@id`; `organization` still adds its details. */
+        organizationId?: string;
+        /** Credited on pages without their own `authors`. */
+        author?: {
+            "@id": string;
+        };
+        /** Every page's publisher, over the Organization. */
+        publisher?: {
+            "@id": string;
+        };
+        /** Emit the WebSite node. Defaults to true unless `websiteId` is set. */
+        website?: boolean;
+    };
+    /**
+     * Date pages without a front matter `date` by the git commit that added
+     * their source file, following exact renames. Defaults to `false`.
+     */
+    datePublished?: false | "git";
     /**
      * Meta tags written into every page's head, name to content: site
      * verification tokens, `theme-color`, an app banner, and anything else
@@ -1136,7 +1167,10 @@ export interface SeoConfig {
     /** RSS/Atom feeds. */
     rss?: RssConfig;
     /** Generate sitemap.xml (requires `deployment.site`). Defaults to `true`. */
-    sitemap?: boolean;
+    sitemap?: boolean | {
+        /** List each page's translations as hreflang links. Defaults to `false`. */
+        alternates?: boolean;
+    };
     /**
      * The documented product, added to the homepage's JSON-LD as a
      * `SoftwareApplication` node. `true` takes every default (name and

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

@@ -104,6 +104,12 @@ export interface BlumeRoute {
     /** True when this route renders fallback content for a missing translation. */
     fallback: boolean;
     hidden: boolean;
+    /**
+     * The translations the page head links as hreflang alternates: the
+     * indexable ones, so a `noindex` or hidden translation is left out (see
+     * `hreflangAlternates`).
+     */
+    hreflang: RouteAlternate[];
     id: string;
     /** Whether the page is part of the search index. */
     indexable: boolean;
@@ -117,6 +123,12 @@ export interface BlumeRoute {
      */
     monolingual: boolean;
     path: string;
+    /**
+     * The git commit that added the page's source, as an ISO date, when
+     * `seo.datePublished` is `"git"` and front matter carries no date; else
+     * `null`.
+     */
+    published: string | null;
     title: string;
     /** Resolved docs version (`""` for the current docs). */
     version: string;
@@ -242,6 +254,7 @@ export interface BlumeDataConfig {
      * kept out of this snapshot, which pages serialize into HTML.
      */
     og: {
+        image?: string | Record<string, string>;
         /**
          * Site-wide card subtitle: `seo.og.description` (`false` omits it) over
          * the site description. A page with its own description shows that
@@ -284,6 +297,7 @@ export interface BlumeDataConfig {
     };
     /** Deployment site URL, or `null` when none is configured/detected. */
     site: string | null;
+    jsonLd: ResolvedConfig["seo"]["jsonLd"];
     structuredData: boolean;
     theme: ResolvedConfig["theme"];
     title: string;

package/dist/types/core/last-modified.d.ts

@@ -7,22 +7,31 @@ export interface ResolvedLastModified {
 export declare const gitEnv: () => NodeJS.ProcessEnv;
 /** Normalize the `lastModified` config (`false | "git" | "frontmatter"`) into `{ enabled, source }`. */
 export declare const resolveLastModifiedConfig: (value: false | "git" | "frontmatter") => ResolvedLastModified;
+/** Each file's git dates, keyed by path. */
+export interface GitDates {
+    /** The committer ISO date of the newest commit that changed the file. */
+    modified: Map<string, string>;
+    /** The committer ISO date of the commit that added the file. */
+    published: Map<string, string>;
+}
 /**
- * Parse `git log --format=%x00%cI --name-status -M100%` output into a map of
- * repo-root-relative path → the committer ISO date of the newest commit that
- * changed the file. Each commit emits a NUL-prefixed date line followed by a
- * status line per path it touched (`M\tpath`, `R100\told\tnew`); since git
- * logs newest-first, the first date seen for a path wins. Blank lines are
- * ignored.
+ * Parse `git log --format=%x00%cI --name-status -M100%` output into each
+ * repo-root-relative path's dates. Each commit emits a NUL-prefixed date line
+ * followed by a status line per path it touched (`M\tpath`, `R100\told\tnew`);
+ * since git logs newest-first, the first date seen for a path is when it last
+ * changed, and the add (`A\tpath`) that ends its history is when it was
+ * published. Blank lines are ignored.
  *
  * A rename (`-M100%` reports only exact ones, where the content is unchanged)
  * follows the file the way `git log --follow` does for one path: it dates
  * nothing itself, and the older commits that name the old path date the file
  * under its current name, so renaming `page.md` to `page.mdx` keeps the page's
- * date. A file whose visible history starts at a rename (a shallow clone cut
- * off the commits before it) takes the rename's date.
+ * dates. A file whose visible history starts at a rename (a shallow clone cut
+ * off the commits before it) takes the rename's date. Only exact renames are
+ * followed: `--follow`'s default 50% similarity would hand a new page the
+ * history of a similar one deleted in the same commit.
  */
-export declare const parseGitLog: (output: string) => Map<string, string>;
+export declare const parseGitLog: (output: string) => GitDates;
 /**
  * `path` with every symlink resolved, the spelling git prints paths in: a
  * project opened through a link (`/tmp/site` on macOS, where `/tmp` links to
@@ -41,17 +50,16 @@ export declare const realPath: (path: string) => string;
  */
 export declare const gitRepositoryRoot: (root: string) => string | null;
 /**
- * Resolve each source file's last-modified date from git history, keyed by
- * absolute source path. Runs a single `git log` over the given content roots
- * (each local source's own root, which may diverge from `content.root`),
- * following renames within them (see `parseGitLog`; a file moved in from
- * outside every root dates from the move), and maps repo-root-relative paths
- * back to the given absolute paths
- * (monorepo-safe via `rev-parse --show-toplevel`). Returns an empty map if git
- * is unavailable or the project isn't a repo — the feature then simply shows
+ * Resolve each source file's git dates (see `parseGitLog`), keyed by absolute
+ * source path. Runs a single `git log` over the given content roots (each
+ * local source's own root, which may diverge from `content.root`), following
+ * renames within them (a file moved in from outside every root dates from the
+ * move), and maps repo-root-relative paths back to the given absolute paths
+ * (monorepo-safe via `rev-parse --show-toplevel`). Returns empty maps if git
+ * is unavailable or the project isn't a repo — the features then simply show
  * no dates.
  */
-export declare const gitLastModifiedTimes: (root: string, contentRoots: string[], sourcePaths: string[], repositoryRoot?: string | null) => Map<string, string>;
+export declare const gitFileDates: (root: string, contentRoots: string[], sourcePaths: string[], repositoryRoot?: string | null) => GitDates;
 /**
  * Whether the repository containing `root` is a shallow clone. Returns false
  * when git is unavailable or the project isn't a repo — those cases already
@@ -67,3 +75,10 @@ export declare const isShallowGitRepository: (root: string) => boolean;
  * shallow.
  */
 export declare const lastModifiedShallowWarning: (root: string, undatedCount: number) => Diagnostic[];
+/**
+ * The warning for `seo.datePublished: "git"` in a shallow clone, where the
+ * oldest commit git can see is where the clone was cut, not where each page
+ * began. Git then dates no page rather than every page wrongly. Empty when
+ * every page has a front matter date.
+ */
+export declare const datePublishedShallowWarning: (undatedCount: number) => Diagnostic[];

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

@@ -33,6 +33,16 @@ export interface RelativeLinkBase {
  * name (`./node.js` for `node.js.mdx`, `./v1.2`) is still a page link.
  */
 export declare const resolveRelativeHref: (href: string, from: RelativeLinkBase, resolveFile?: (path: string) => string | undefined, hasRoute?: (route: string) => boolean) => string | undefined;
+/**
+ * Where a relative page link in a raw HTML `<a href>` written on `route`
+ * lands, with the authored `?query#hash` kept, or `undefined` when `href`
+ * isn't a relative page link (see {@link resolveRelativeHref}). The Markdown
+ * pipeline leaves a raw element as written, so the browser resolves it
+ * against the page's slashless URL, as `blume validate` reads it: its parent
+ * directory, even on an index page, and a `.md` target is that path's
+ * Markdown copy rather than a file link.
+ */
+export declare const resolveRawRelativeHref: (href: string, route: string, hasRoute: (route: string) => boolean) => string | undefined;
 /**
  * Where a root-relative link to a content file (`/guide/new.md`, the way
  * VitePress, Docsify, and TypeDoc write one) lands: the route of the source
@@ -96,6 +106,12 @@ export declare const buildFileRouteIndex: (pages: readonly PageRecord[], i18n: L
  * tree's file at the same place.
  */
 export declare const routeOfLinkedFile: (index: FileRouteIndex, from: FileLinkBase, path: string) => string | undefined;
+/**
+ * The route a file link written on a staged page lands on: the linked
+ * entry's, by its path under the staging dir (`entryId`), as the rendered
+ * link resolves it.
+ */
+export declare const routeOfLinkedEntry: (index: FileRouteIndex, entryId: string, path: string) => string | undefined;
 /**
  * Validate every link discovered in the content graph: internal page links and
  * anchors against the route map, asset links against the public dir, and

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

@@ -4048,6 +4048,18 @@ export declare const blumeConfigSchema: z.ZodObject<{
         }>>>>;
     }, z.core.$strict>>>;
     seo: z.ZodPrefault<z.ZodObject<{
+        datePublished: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodLiteral<"git">]>>;
+        jsonLd: z.ZodPrefault<z.ZodObject<{
+            author: z.ZodOptional<z.ZodObject<{
+                "@id": z.ZodURL;
+            }, z.core.$strict>>;
+            organizationId: z.ZodOptional<z.ZodURL>;
+            publisher: z.ZodOptional<z.ZodObject<{
+                "@id": z.ZodURL;
+            }, z.core.$strict>>;
+            website: z.ZodOptional<z.ZodBoolean>;
+            websiteId: z.ZodOptional<z.ZodURL>;
+        }, z.core.$strict>>;
         metatags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         og: z.ZodDefault<z.ZodObject<{
             description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>]>>;
@@ -4071,6 +4083,7 @@ export declare const blumeConfigSchema: z.ZodObject<{
                 }>>;
                 weight: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strict>]>>>;
+            image: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
             logo: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<false>]>>;
             palette: z.ZodOptional<z.ZodObject<{
                 accent: z.ZodOptional<z.ZodString>;
@@ -4104,7 +4117,9 @@ export declare const blumeConfigSchema: z.ZodObject<{
             limit: z.ZodDefault<z.ZodNumber>;
             types: z.ZodDefault<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>;
-        sitemap: z.ZodDefault<z.ZodBoolean>;
+        sitemap: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            alternates: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>]>>;
         software: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
             applicationCategory: z.ZodDefault<z.ZodString>;
             description: z.ZodOptional<z.ZodString>;

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

@@ -245,6 +245,11 @@ export interface PageRecord {
     unknownProps?: ElementUse[];
     /** Resolved "last updated" ISO date, when the feature is enabled. */
     lastModified?: string;
+    /**
+     * The git commit that added the source file, as an ISO date, when
+     * `seo.datePublished` is `"git"` and front matter carries no `date`.
+     */
+    published?: string;
     /** Absolute paths of files this page `<include>`s, transitively. Drives the
      * dev-server invalidation edge from a partial to the pages that splice it. */
     includes?: string[];
@@ -461,6 +466,11 @@ export interface RouteManifestEntry {
     aiExclude?: boolean;
     /** Resolved "last updated" ISO date, when the feature is enabled. */
     lastModified?: string;
+    /**
+     * The git commit that added the source file, as an ISO date, when
+     * `seo.datePublished` is `"git"` and front matter carries no `date`.
+     */
+    published?: string;
 }
 /** The generated runtime contract between core and the Astro project. */
 export interface BlumeManifest {

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

@@ -1,4 +1,5 @@
 import type { BlumeProject } from "../core/project-graph.ts";
+import type { RouteAlternate } from "../core/types.ts";
 /** One emitted sitemap artifact: its dist-root filename and XML body. */
 export interface SitemapFile {
     name: string;
@@ -6,6 +7,14 @@ export interface SitemapFile {
 }
 /** The build log line for an emitted sitemap set: one file, or an index. */
 export declare const describeSitemapFiles: (files: readonly SitemapFile[]) => string;
+/**
+ * Each route's hreflang set, keyed by route: its indexable translations. The
+ * page head links it, and so does the sitemap under `seo.sitemap.alternates`,
+ * so the two never disagree, and neither points crawlers at a page they're
+ * told not to index. A page that can't be indexed joins no set — except an
+ * i18n fallback copy, which links the translations it stands in for.
+ */
+export declare const hreflangAlternates: (project: BlumeProject) => Map<string, RouteAlternate[]>;
 /**
  * Build the sitemap files from the route manifest plus the routes the manifest
  * can't see: custom `.astro` pages (most importantly a custom landing `/`) and

package/dist/types/search/documents.d.ts

@@ -79,7 +79,9 @@ interface BuildOptions {
  * same serializers the `.md` mirror, llms-full.txt and MCP `get_page` use: a
  * page whose body is a `<CardGroup>` of `<Card>`s is prose to a reader and bare
  * JSX to anything reading the source, and section landing pages are exactly
- * that shape.
+ * that shape. Its page links point at the pages they mean, as they do there
+ * too, as the routes the assistant's snapshot keys those pages by (see
+ * `relativeLinkRewriter`'s `assistant`): the model cites the links it reads.
  *
  * `audience` resolves `<Visibility>` blocks before extraction: `"web"`
  * (default) keeps web-only content and drops agents-only blocks — the site

package/dist/types/search/fold.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Latin folding, shared by the search index and everything that finds a query
+ * in a page's text afterwards: the search dialog's highlights and excerpts,
+ * and the assistant's excerpts. The index matches Prüfung for `prufung`, so
+ * the rest must too, or a page found by folding shows its opening with
+ * nothing marked.
+ */
+/** `text` without its soft hyphens. */
+export declare const stripSoftHyphens: (text: string) => string;
+/**
+ * Fold lowercased text's Latin letters to the plain letters an unaccented
+ * query types: accents drop (café → cafe), letters NFD leaves whole are
+ * spelled out (Łódź → lodz, ışık and IŞIK → isik, Straße → strasse), and
+ * compatibility forms unpack (the fi ligature → fi, fullwidth ＡＰＩ → api).
+ * Soft hyphens go too. Marks on any other script, and marks on no letter
+ * (the keycap in 1️⃣), stay.
+ */
+export declare const foldLatin: (lowered: string) => string;
+/**
+ * {@link foldLatin} for the Latin letters of a lowercased term, whatever
+ * script the rest of it is in: a segmenter keeps caféनमस्ते together as one
+ * term. Only the Latin runs fold. Marks are spelling elsewhere (Thai vowels
+ * and tones; the breve that separates Cyrillic й from и), and NFD would split
+ * a Hangul syllable into its jamo.
+ */
+export declare const foldLatinTerm: (term: string) => string;
+/**
+ * A regex source that finds `term` in unfolded text whatever accents, soft
+ * hyphens or spelled-out letters its Latin words carry there: `prufung`
+ * matches Prüfung, `strasse` matches Straße. Compile it with the `iu` flags.
+ * Characters outside Latin match as themselves.
+ */
+export declare const accentInsensitive: (term: string) => string;

package/dist/types/search/orama-index.d.ts

@@ -34,10 +34,10 @@ export interface OramaDoc {
  * Orama client loader (browser), the MCP server, and assistant grounding (Node),
  * so ranking is identical wherever docs are queried. `locale` — the site's
  * `i18n.defaultLocale` — swaps in a word-segmenting tokenizer for every
- * non-Latin script, all of which Orama's default tokenizer reduces to zero
+ * non-Latin script, all of which {@link latinTokenizer} reduces to zero
  * tokens. A non-Latin default's tokenizer serves every page: Latin words
  * survive segmentation intact, so English pages on a segmented index stay
- * searchable. A Latin default keeps Orama's tokenizer for its Latin-script
+ * searchable. A Latin default keeps {@link latinTokenizer} for its Latin-script
  * pages, and each page in a non-Latin locale (the Japanese and Hindi
  * translations of an English site) is indexed with its own locale's tokenizer.
  */
@@ -68,7 +68,7 @@ export interface OramaQueryFilters {
  * On an index whose translations have tokenizers of their own, a query scoped
  * to a locale is tokenized with that locale's tokenizer. An unscoped query
  * searches each locale's pages with its own tokenizer, and the Latin-script
- * pages with Orama's, then merges the matches by score: every search runs over
- * the one index, so their scores share its term statistics.
+ * pages with {@link latinTokenizer}, then merges the matches by score: every
+ * search runs over the one index, so their scores share its term statistics.
  */
 export declare const queryOramaIndex: (db: AnyOrama, term: string, limit: number, filters?: OramaQueryFilters) => Promise<OramaDoc[]>;

package/dist/types/seo/jsonld.d.ts

@@ -53,8 +53,41 @@ export interface StructuredDataIdentity {
     organization?: OrganizationIdentity;
     software?: SoftwareIdentity;
 }
+/**
+ * `seo.jsonLd`: entities the docs share with a site they live inside
+ * (`example.com/docs`), referenced by `@id` instead of defined again.
+ */
+export interface JsonLdEntities {
+    /** Credited on pages without their own `authors`. */
+    author?: {
+        "@id": string;
+    };
+    /** Cited as every page's publisher in place of the Organization's id. */
+    publisher?: {
+        "@id": string;
+    };
+    /** The Organization's `@id`, defined here or elsewhere. */
+    organizationId?: string;
+    /** Emit the WebSite node. Defaults to true unless `websiteId` is set. */
+    website?: boolean;
+    /** The WebSite's `@id`, which every page names as `isPartOf`. */
+    websiteId?: string;
+}
+/** A front matter `authors` entry: a name, or a name with a profile URL. */
+export type AuthorInput = string | {
+    name: string;
+    url?: string;
+};
 /** Inputs for a page's JSON-LD, all known at render time in RootLayout. */
 export interface StructuredDataInput {
+    jsonLd?: JsonLdEntities;
+    /**
+     * The page's `og:image`, emitted as the page node's `image`. Absolute when
+     * `siteUrl` is set, otherwise root-relative like every other URL here.
+     */
+    image?: string | null;
+    /** The page's own byline, which wins over `jsonLd.author`. */
+    authors?: AuthorInput | AuthorInput[];
     siteName: string;
     /** Absolute site origin, or null when `deployment.site` is unset. */
     siteUrl: string | null;

package/docs/configuration/search.mdx

@@ -149,7 +149,7 @@ search: orama(),
 
 #### Non-Latin scripts
 
-Orama's standard tokenizer keeps only basic Latin letters, digits and a handful of accented vowels, so text in any other script — Japanese, Chinese, Korean and Thai, but equally Russian, Greek, Hebrew and Hindi — would otherwise produce no matches at all. Blume handles this for you: pages in a locale that resolves to a non-Latin script are indexed with a word-segmenting tokenizer (built on the browser- and Node-native `Intl.Segmenter`). Declaring your site's languages is all it takes:
+The standard tokenizer keeps only Latin letters and digits, so text in any other script — Japanese, Chinese, Korean and Thai, but equally Russian, Greek, Hebrew and Hindi — would otherwise produce no matches at all. Blume handles this for you: pages in a locale that resolves to a non-Latin script are indexed with a word-segmenting tokenizer (built on the browser- and Node-native `Intl.Segmenter`). Declaring your site's languages is all it takes:
 
 ```ts blume.config.ts lineNumbers
 i18n: {
@@ -158,7 +158,7 @@ i18n: {
 }
 ```
 
-The same tokenizers serve the search dialog, the MCP server's `search_docs` tool, and assistant grounding. The script is what decides, not the language name — `az-Cyrl` is segmented while `sr-Latn` is not. With a non-Latin default, every page shares the default locale's tokenizer: Latin words survive segmentation intact, so pages in English stay searchable alongside the default language. With a Latin default, Latin-script pages keep the standard tokenizer and each translation in a non-Latin script gets its own locale's, so an English site's Japanese and Hindi pages are searchable from their own language and from a search across every language. Latin-script languages that lean heavily on diacritics (Vietnamese, or Serbian in Latin script) also fare worse on the standard tokenizer, which folds only a few accented vowels and splits words on the rest.
+The same tokenizers serve the search dialog, the MCP server's `search_docs` tool, and assistant grounding. The script is what decides, not the language name — `az-Cyrl` is segmented while `sr-Latn` is not. With a non-Latin default, every page shares the default locale's tokenizer: Latin words survive segmentation intact, so pages in English stay searchable alongside the default language. With a Latin default, Latin-script pages keep the standard tokenizer and each translation in a non-Latin script gets its own locale's, so an English site's Japanese and Hindi pages are searchable from their own language and from a search across every language. The standard tokenizer strips accents and spells out letters that have none to strip (ø as o, ł as l, ß as ss), so `cafe` finds café and `lodz` finds Łódź, and the search dialog and the assistant's excerpts find the accented word in the page too. Where accents tell words apart (Swedish ändra and andra, Vietnamese tones), a query also matches words that differ from it only in those accents.
 
 Japanese and Chinese go one step further. Segmenting alone indexes a compound term as its parts — 資金決済法 as 資金, 決済 and 法 — which lets a page mentioning each part somewhere outrank the page the term is actually about. Han, Hiragana and Katakana are therefore indexed as overlapping character pairs, and queries on those indexes prefer pages carrying a term's pairs together, loosening to any-pair matching when no page carries them all, so typing a whole sentence still returns its closest pages. Korean and Thai keep their segmented words.