blume 2.2.2 → 2.2.3

package/src/components/layout/locale-redirect.ts

@@ -65,6 +65,7 @@ export const LOCALE_REDIRECT_SCRIPT = `(()=>{const s=document.currentScript;if(!
 interface ClosestTarget {
   closest: (selector: string) => {
     getAttribute: (name: string) => string | null;
+    setAttribute: (name: string, value: string) => void;
   } | null;
 }
 
@@ -75,33 +76,51 @@ interface Click {
 
 /** What {@link rememberLocaleChoice} listens on: the document. */
 export interface ChoiceTarget {
-  addEventListener: (type: "click", listener: (event: Click) => void) => void;
+  addEventListener: (
+    type: "click",
+    listener: (event: Click) => void,
+    options: { capture: true }
+  ) => void;
+  location: { readonly hash: string };
 }
 
 const hasClosest = (target: Click["target"]): target is ClosestTarget =>
   target !== null && "closest" in target;
 
-/** The code of the switcher link a click landed on, if any. */
-const chosenCode = (target: Click["target"]): string | null | undefined =>
-  hasClosest(target)
-    ? target.closest("a[data-blume-locale-choice]")?.getAttribute("hreflang")
-    : null;
+/** The switcher link a click landed on, if any. */
+const chosenLink = (target: Click["target"]) =>
+  hasClosest(target) ? target.closest("a[data-blume-locale-choice]") : null;
 
 /**
  * Remember a language picked with the switcher, so routing by browser
- * language stops sending the reader elsewhere. One listener on the document
- * covers every switcher, on every page the client router swaps in.
+ * language stops sending the reader elsewhere, and keep the reader's place:
+ * the chosen link carries the current fragment (a heading the translation
+ * lacks leaves the reader at the top). One listener on the document covers
+ * every switcher, on every page the client router swaps in. It listens in
+ * the capture phase: the client router's own listener on the document reads
+ * the link's href and navigates, and it's registered first.
  */
 export const rememberLocaleChoice = (target: ChoiceTarget): void => {
-  target.addEventListener("click", (event) => {
-    const code = chosenCode(event.target);
-    if (!code) {
-      return;
-    }
-    try {
-      localStorage.setItem(LOCALE_STORAGE_KEY, code);
-    } catch {
-      // Storage can be off; routing then stays off too (see the script).
-    }
-  });
+  target.addEventListener(
+    "click",
+    (event) => {
+      const link = chosenLink(event.target);
+      const code = link?.getAttribute("hreflang");
+      if (!(link && code)) {
+        return;
+      }
+      // Rewritten even without a fragment, so one left by an earlier click
+      // (one that opened a new tab) doesn't stick.
+      const href = link.getAttribute("href");
+      if (href !== null) {
+        link.setAttribute("href", href.split("#")[0] + target.location.hash);
+      }
+      try {
+        localStorage.setItem(LOCALE_STORAGE_KEY, code);
+      } catch {
+        // Storage can be off; routing then stays off too (see the script).
+      }
+    },
+    { capture: true }
+  );
 };

package/src/components/layout/search/types.ts

@@ -1,5 +1,7 @@
 import { escape } from "html-escaper";
 
+import { accentInsensitive } from "../../../search/fold.ts";
+
 /** A single result rendered in the search dialog. */
 export interface SearchHit {
   url: string;
@@ -96,16 +98,19 @@ export const SEARCH_LIMIT = 12;
  */
 export const RESULT_POOL = 48;
 
-const REGEXP_SPECIAL = /[$()*+.?[\\\]^{|}]/gu;
 const WORD_BREAK = /\s+/u;
 
-/** Split a query into escaped, non-empty search tokens. */
+/**
+ * Split a query into non-empty search tokens, each a regex source that
+ * matches it whatever accents the text carries: the index folds Prüfung to
+ * prufung, so a page found by `prufung` is marked and excerpted there too.
+ */
 const queryTokens = (query: string): string[] =>
   query
     .trim()
     .split(WORD_BREAK)
     .filter(Boolean)
-    .map((token) => token.replaceAll(REGEXP_SPECIAL, String.raw`\$&`));
+    .map((token) => accentInsensitive(token));
 
 /**
  * Wrap query matches in `<mark>`, HTML-escaping the source text. Matching runs
@@ -159,7 +164,10 @@ export const sanitizeExcerpt = (html: string): string =>
     })
     .join("");
 
-/** First index in `text` where any query token matches (case-insensitive). */
+/**
+ * First index in `text` where any query token matches, ignoring case and
+ * accents.
+ */
 const matchIndex = (text: string, query: string): number => {
   const tokens = queryTokens(query);
   if (tokens.length === 0) {

package/src/core/config-input.ts

@@ -1099,6 +1099,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.
@@ -1223,6 +1229,28 @@ 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
@@ -1262,7 +1290,12 @@ 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/src/core/config.ts

@@ -394,8 +394,11 @@ export const loadConfig = async (
   const site = config.deployment.options.site ?? options.devServerUrl;
 
   // OG images need an absolute `og:image`, so they default on once a site URL
-  // is known and off otherwise. An explicit `seo.og.enabled` always wins.
-  const ogEnabled = config.seo.og.enabled ?? Boolean(site);
+  // is known and off otherwise — and off beside a default `seo.og.image`,
+  // which every page shows instead of its card. An explicit `seo.og.enabled`
+  // always wins.
+  const ogEnabled =
+    config.seo.og.enabled ?? (Boolean(site) && !config.seo.og.image);
 
   return {
     config: {

package/src/core/data.ts

@@ -100,6 +100,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;
@@ -113,6 +119,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;
@@ -229,6 +241,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
@@ -265,6 +278,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/src/core/last-modified.ts

@@ -40,27 +40,41 @@ export const resolveLastModifiedConfig = (
     ? { enabled: false, source: "git" }
     : { enabled: true, source: value };
 
+/** 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 const parseGitLog = (output: string): Map<string, string> => {
-  const times = new Map<string, string>();
+export const parseGitLog = (output: string): GitDates => {
+  const modified = new Map<string, string>();
+  const published = new Map<string, string>();
   // An older name of a file → its name now, for the commits read after the
   // rename (older ones).
   const currentNames = new Map<string, string>();
   const renamedAt = new Map<string, string>();
+  // Files whose add has been read: anything older under the same name was an
+  // earlier file at that path, deleted before this one was created.
+  const added = new Set<string>();
   let current: string | null = null;
   for (const line of output.split("\n")) {
     if (line.startsWith("\0")) {
@@ -73,21 +87,27 @@ export const parseGitLog = (output: string): Map<string, string> => {
       continue;
     }
     const name = currentNames.get(path) ?? path;
+    if (!added.has(name)) {
+      published.set(name, current);
+      if (status === "A") {
+        added.add(name);
+      }
+    }
     if (status.startsWith("R")) {
       currentNames.set(from, name);
       if (!renamedAt.has(name)) {
         renamedAt.set(name, current);
       }
-    } else if (!times.has(name)) {
-      times.set(name, current);
+    } else if (!modified.has(name)) {
+      modified.set(name, current);
     }
   }
   for (const [name, date] of renamedAt) {
-    if (!times.has(name)) {
-      times.set(name, date);
+    if (!modified.has(name)) {
+      modified.set(name, date);
     }
   }
-  return times;
+  return { modified, published };
 };
 
 /**
@@ -127,37 +147,38 @@ export const gitRepositoryRoot = (root: string): string | null => {
   }
 };
 
+const noDates = (): GitDates => ({ modified: new Map(), published: new Map() });
+
 /**
- * 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 const gitLastModifiedTimes = (
+export const gitFileDates = (
   root: string,
   contentRoots: string[],
   sourcePaths: string[],
   repositoryRoot?: string | null
-): Map<string, string> => {
+): GitDates => {
   // Nothing to date, or nowhere bounded to look — either way, don't pay for a
   // git scan. Both guards matter: `git log -- ` with no pathspec logs the
   // entire repository, which is what an all-staged project produces (a staged
   // source contributes no content root, yet its entries can still carry a
   // `sourcePath`).
   if (sourcePaths.length === 0 || contentRoots.length === 0) {
-    return new Map();
+    return noDates();
   }
   // The caller that bounded `contentRoots` already resolved the repo root;
   // reuse it rather than spawning `rev-parse` a second time per scan.
   const gitRoot =
     repositoryRoot === undefined ? gitRepositoryRoot(root) : repositoryRoot;
   if (gitRoot === null) {
-    return new Map();
+    return noDates();
   }
   // Git names paths by their real location, so the pathspecs and the paths
   // read back against the log are compared in that spelling too (see
@@ -185,16 +206,19 @@ export const gitLastModifiedTimes = (
       { encoding: "utf-8", env: gitEnv(), maxBuffer: 256 * 1024 * 1024 }
     );
     const byRepoPath = parseGitLog(output);
-    const result = new Map<string, string>();
+    const result = noDates();
     for (const sourcePath of sourcePaths) {
-      const iso = byRepoPath.get(relative(top, realPath(sourcePath)));
-      if (iso) {
-        result.set(sourcePath, iso);
+      const repoPath = relative(top, realPath(sourcePath));
+      for (const key of ["modified", "published"] as const) {
+        const iso = byRepoPath[key].get(repoPath);
+        if (iso) {
+          result[key].set(sourcePath, iso);
+        }
       }
     }
     return result;
   } catch {
-    return new Map();
+    return noDates();
   }
 };
 
@@ -223,6 +247,9 @@ export const isShallowGitRepository = (root: string): boolean => {
   }
 };
 
+const SHALLOW_CLONE_SUGGESTION =
+  "Fetch full history in CI: set the VERCEL_DEEP_CLONE=true environment variable on Vercel, or fetch-depth: 0 for actions/checkout.";
+
 /**
  * A warning for git-derived dates silently missing because the build ran in a
  * shallow clone — the default on Vercel and `actions/checkout`, where `git log`
@@ -243,8 +270,27 @@ export const lastModifiedShallowWarning = (
       code: "BLUME_SHALLOW_GIT_HISTORY",
       message: `lastModified is on, but this build runs in a shallow git clone, so ${undatedCount} page(s) have no git-derived date — their sitemap <lastmod> and "Last updated" stamps are omitted.`,
       severity: "warning",
-      suggestion:
-        "Fetch full history in CI: set the VERCEL_DEEP_CLONE=true environment variable on Vercel, or fetch-depth: 0 for actions/checkout.",
+      suggestion: SHALLOW_CLONE_SUGGESTION,
     },
   ];
 };
+
+/**
+ * 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 const datePublishedShallowWarning = (
+  undatedCount: number
+): Diagnostic[] =>
+  undatedCount === 0
+    ? []
+    : [
+        {
+          code: "BLUME_SHALLOW_GIT_HISTORY",
+          message: `seo.datePublished is "git", but this build runs in a shallow git clone, so ${undatedCount} page(s) without a front matter date have no datePublished.`,
+          severity: "warning",
+          suggestion: SHALLOW_CLONE_SUGGESTION,
+        },
+      ];

package/src/core/links.ts

@@ -249,6 +249,36 @@ export const resolveRelativeHref = (
   return `${fileRoute ?? toRoute(resolveRelative(from.route, path, from.isIndex))}${suffix}`;
 };
 
+/**
+ * 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 const resolveRawRelativeHref = (
+  href: string,
+  route: string,
+  hasRoute: (route: string) => boolean
+): string | undefined => {
+  if (href === "" || NOT_RELATIVE.test(href)) {
+    return undefined;
+  }
+  const suffixAt = href.search(/[?#]/u);
+  const path = suffixAt === -1 ? href : href.slice(0, suffixAt);
+  const resolved = resolveRelative(route, path, false);
+  if (
+    FILE_EXT.test(path) &&
+    !DOC_EXT.test(path) &&
+    !hasRoute(decodePercent(resolved))
+  ) {
+    return undefined;
+  }
+  return `${resolved}${suffixAt === -1 ? "" : href.slice(suffixAt)}`;
+};
+
 /**
  * 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
@@ -695,6 +725,18 @@ export const routeOfLinkedFile = (
   index.bySource.get(resolve(dirname(from.sourcePath), path)) ??
   index.byDefaultNavPath.get(normalize(join(dirname(from.navPath), path)));
 
+/**
+ * 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 const routeOfLinkedEntry = (
+  index: FileRouteIndex,
+  entryId: string,
+  path: string
+): string | undefined =>
+  index.byEntryId.get(normalize(join(dirname(entryId), path)));
+
 /**
  * The path a relative link on `page` resolves to — the same reading the
  * Markdown pipeline rewrites the rendered `href` to (see
@@ -714,8 +756,7 @@ const relativeTarget = (
     resolveFile = (path) =>
       routeOfLinkedFile(ctx.fileRoutes, { navPath, sourcePath }, path);
   } else if (entryId) {
-    resolveFile = (path) =>
-      ctx.fileRoutes.byEntryId.get(normalize(join(dirname(entryId), path)));
+    resolveFile = (path) => routeOfLinkedEntry(ctx.fileRoutes, entryId, path);
   }
   return (
     resolveRelativeHref(rawPath, base, resolveFile, (route) =>

package/src/core/manifest.ts

@@ -136,6 +136,7 @@ const buildFallbackRoutes = (
         locale: code,
         monolingual: source.monolingual,
         path,
+        published: source.published,
         source: source.source,
         sourcePath: source.sourcePath,
         title: source.title,
@@ -201,6 +202,7 @@ export const buildManifest = (options: {
     locale: page.locale,
     monolingual: page.monolingual,
     path: page.route,
+    published: page.published,
     source: page.source,
     sourcePath: page.sourcePath,
     title: page.title,

package/src/core/project-graph.ts

@@ -14,8 +14,10 @@ import { buildContentGraph } from "./graph.ts";
 import { i18nDiagnostics } from "./i18n.ts";
 import { expandIncludes, hasIncludeStatements } from "./includes.ts";
 import {
-  gitLastModifiedTimes,
+  datePublishedShallowWarning,
+  gitFileDates,
   gitRepositoryRoot,
+  isShallowGitRepository,
   lastModifiedShallowWarning,
   realPath,
   resolveLastModifiedConfig,
@@ -301,6 +303,82 @@ const gitContentRoots = (
     .filter((dir) => isWithin(top, realPath(dir)));
 };
 
+/** Whether a page's front matter dates its publication itself. */
+const hasPublishedDate = (page: PageRecord): boolean =>
+  Boolean(page.meta.date ?? page.meta.changelog?.date);
+
+/**
+ * Fill in each page's git dates — "last updated" under `lastModified: "git"`,
+ * published under `seo.datePublished: "git"` — from one `git log`, and warn
+ * when a shallow clone leaves pages undated. Frontmatter always wins; git
+ * applies to filesystem entries, other sources supply dates on the entry.
+ */
+const applyGitDates = (
+  pages: PageRecord[],
+  sources: readonly ContentSource[],
+  root: string,
+  config: ResolvedConfig
+): Diagnostic[] => {
+  const lastModified = resolveLastModifiedConfig(config.lastModified);
+  const gitModified = lastModified.enabled && lastModified.source === "git";
+  const gitPublished = config.seo.datePublished === "git";
+  if (!(gitModified || gitPublished)) {
+    return [];
+  }
+  const fsPaths = pages
+    .map((page) => page.sourcePath)
+    .filter((path): path is string => path !== undefined);
+  // The git pathspecs must cover where the pages actually live: each local
+  // source's own on-disk root — a filesystem source's `root`, or a staged
+  // local source's tree (an Obsidian vault) — which diverges from the global
+  // `content.root`.
+  const gitRoot = gitRepositoryRoot(root);
+  const contentRoots = gitContentRoots(sources, gitRoot);
+  const gitDates = gitFileDates(root, contentRoots, fsPaths, gitRoot);
+  // Only pages the log could have dated count toward the shallow-clone
+  // warnings — a page outside every covered root stays undated no matter how
+  // deep the clone is, and the warning's suggested fix cannot help it.
+  const datable = pages.filter(
+    (page) =>
+      page.sourcePath &&
+      contentRoots.some((dir) => isWithin(dir, page.sourcePath ?? ""))
+  );
+  const warnings: Diagnostic[] = [];
+  if (gitModified) {
+    for (const page of pages) {
+      if (!page.lastModified && page.sourcePath) {
+        page.lastModified = gitDates.modified.get(page.sourcePath);
+      }
+    }
+    // A shallow CI clone (Vercel, actions/checkout) silently drops most dates;
+    // surface that instead of letting production diverge from local builds.
+    warnings.push(
+      ...lastModifiedShallowWarning(
+        root,
+        datable.filter((page) => !page.lastModified).length
+      )
+    );
+  }
+  if (gitPublished) {
+    // A shallow clone's oldest commit is where it was cut, not where a page
+    // began, so it dates nothing rather than every page wrongly.
+    const shallow = isShallowGitRepository(root);
+    for (const page of pages) {
+      if (!(shallow || hasPublishedDate(page)) && page.sourcePath) {
+        page.published = gitDates.published.get(page.sourcePath);
+      }
+    }
+    if (shallow) {
+      warnings.push(
+        ...datePublishedShallowWarning(
+          datable.filter((page) => !hasPublishedDate(page)).length
+        )
+      );
+    }
+  }
+  return warnings;
+};
+
 /**
  * Run the full core pipeline for a project root: load config, resolve paths,
  * discover content and folder meta, build the graph, and assemble the manifest.
@@ -681,47 +759,9 @@ export const scanProject = async (
       ? allPages.filter((page) => !page.meta.draft)
       : allPages;
 
-  // Resolve "last updated" dates before the graph is built so the manifest
-  // (which shares these page objects) picks them up. Frontmatter always wins;
-  // git applies to filesystem entries, other sources supply dates on the entry.
-  const lastModified = resolveLastModifiedConfig(config.lastModified);
-  const lastModifiedWarnings: Diagnostic[] = [];
-  if (lastModified.enabled && lastModified.source === "git") {
-    const fsPaths = pages
-      .map((page) => page.sourcePath)
-      .filter((path): path is string => path !== undefined);
-    // The git pathspecs must cover where the pages actually live: each local
-    // source's own on-disk root — a filesystem source's `root`, or a staged
-    // local source's tree (an Obsidian vault) — which diverges from the global
-    // `content.root`.
-    const gitRoot = gitRepositoryRoot(context.root);
-    const contentRoots = gitContentRoots(sources, gitRoot);
-    const gitTimes = gitLastModifiedTimes(
-      context.root,
-      contentRoots,
-      fsPaths,
-      gitRoot
-    );
-    for (const page of pages) {
-      if (!page.lastModified && page.sourcePath) {
-        page.lastModified = gitTimes.get(page.sourcePath);
-      }
-    }
-    // A shallow CI clone (Vercel, actions/checkout) silently drops most dates;
-    // surface that instead of letting production diverge from local builds.
-    // Only pages the log could have dated count — a page outside every covered
-    // root stays undated no matter how deep the clone is, and the warning's
-    // suggested fix cannot help it.
-    const undated = pages.filter(
-      (page) =>
-        page.sourcePath &&
-        !page.lastModified &&
-        contentRoots.some((dir) => isWithin(dir, page.sourcePath ?? ""))
-    ).length;
-    lastModifiedWarnings.push(
-      ...lastModifiedShallowWarning(context.root, undated)
-    );
-  }
+  // Resolve "last updated" and publication dates before the graph is built so
+  // the manifest (which shares these page objects) picks them up.
+  const gitDateWarnings = applyGitDates(pages, sources, context.root, config);
 
   // Custom `.astro` pages and the generated changelog index aren't content
   // pages, so name them for navigation: a `/changelog` tab should open the
@@ -791,7 +831,7 @@ export const scanProject = async (
       ...graph.diagnostics,
       ...i18nWarnings,
       ...versionWarnings,
-      ...lastModifiedWarnings,
+      ...gitDateWarnings,
       ...svgWarnings,
       ...publicOpenApiDiagnostics(config, context.root),
       ...redirectPageDiagnostics(