blume 2.2.2 → 2.2.4

package/src/components/layout/RootLayout.astro

@@ -43,6 +43,7 @@ import {
   OG_IMAGE_WIDTH,
 } from "../../og/dimensions.ts";
 import { buildStructuredData, toIso } from "../../seo/jsonld.ts";
+import type { AuthorInput } from "../../seo/jsonld.ts";
 import { normalizeXHandle } from "../../seo/x-handle.ts";
 import { withBase, withMountedBase } from "../islands/base-path.ts";
 import { routeSetFor } from "../../core/locale-links.ts";
@@ -196,6 +197,8 @@ interface Props {
   /** The page's `mode` frontmatter: what it shows around its content (see `core/page-modes.ts`). */
   pageMode?: PageMode;
   published?: string | Date | null;
+  /** The page's front matter `authors`, credited in its JSON-LD. */
+  authors?: AuthorInput | AuthorInput[];
   lastModified?: string | null;
   noindex?: boolean;
   structuredDataEnabled?: boolean;
@@ -312,6 +315,7 @@ const {
   apiRail = false,
   pageMode,
   published,
+  authors,
   lastModified,
   noindex,
   structuredDataEnabled,
@@ -534,11 +538,14 @@ const structuredData =
   structuredDataEnabled === false || noindex
     ? null
     : buildStructuredData({
+      authors,
       base: import.meta.env.BASE_URL,
       breadcrumbs: crumbs,
       description,
       homeRoute: navigation.root,
       identity: data.config.identity,
+      jsonLd: data.config.jsonLd,
+      image: ogImage,
       locale,
       modified: lastModified,
       pageType,
@@ -685,7 +692,12 @@ const localeRedirect = localeTargets
         <script data-key={bannerKey} is:inline set:html={BANNER_INIT_SCRIPT} />
       )
     }
-    <script data-mode={themeMode} is:inline set:html={THEME_INIT_SCRIPT} />
+    <script
+      data-fixed={data.config.theme.toggle ? undefined : ""}
+      data-mode={themeMode}
+      is:inline
+      set:html={THEME_INIT_SCRIPT}
+    />
     {consent && <ConsentHead consent={consent} />}
     <Analytics analytics={analytics} />
   </head>

package/src/components/layout/head-scripts.ts

@@ -45,12 +45,16 @@
  * after a swap the theme the `before-swap` stamp carried over stands, so a
  * toggle the reader made still holds for the rest of their visit.
  *
+ * `data-fixed` (present when `theme.toggle` is off) skips the stored
+ * preference, so a choice saved before the toggle was removed can't hold the
+ * page in a mode the site no longer offers.
+ *
  * Paper is white, so a dark page prints light: `beforeprint` switches the root
  * to the light theme (every token, Shiki color, and `dark:` utility follows
  * it) and `afterprint` puts the dark theme back. The listeners sit on
  * `window`, so the one registration outlives client-router swaps.
  */
-export const THEME_INIT_SCRIPT = `(()=>{const m=document.currentScript?.dataset.mode??"system";const apply=()=>{const r=document.documentElement;let s=null;let blocked=false;try{s=localStorage.getItem("blume-theme");}catch{blocked=true;}const sys=matchMedia("(prefers-color-scheme: dark)").matches?"dark":"light";r.dataset.theme=s??(blocked&&r.dataset.theme?r.dataset.theme:m==="system"?sys:m);};apply();document.addEventListener("astro:before-swap",(e)=>{const t=document.documentElement.dataset.theme;if(t){e.newDocument.documentElement.dataset.theme=t;}});document.addEventListener("astro:after-swap",apply);let printed=null;addEventListener("beforeprint",()=>{const r=document.documentElement;if(r.dataset.theme==="dark"){printed="dark";r.dataset.theme="light";}});addEventListener("afterprint",()=>{if(printed){document.documentElement.dataset.theme=printed;printed=null;}});})();`;
+export const THEME_INIT_SCRIPT = `(()=>{const ds=document.currentScript?.dataset;const m=ds?.mode??"system";const fixed=ds?.fixed!==undefined;const apply=()=>{const r=document.documentElement;let s=null;let blocked=false;try{s=fixed?null:localStorage.getItem("blume-theme");}catch{blocked=true;}const sys=matchMedia("(prefers-color-scheme: dark)").matches?"dark":"light";r.dataset.theme=s??(blocked&&r.dataset.theme?r.dataset.theme:m==="system"?sys:m);};apply();document.addEventListener("astro:before-swap",(e)=>{const t=document.documentElement.dataset.theme;if(t){e.newDocument.documentElement.dataset.theme=t;}});document.addEventListener("astro:after-swap",apply);let printed=null;addEventListener("beforeprint",()=>{const r=document.documentElement;if(r.dataset.theme==="dark"){printed="dark";r.dataset.theme="light";}});addEventListener("afterprint",()=>{if(printed){document.documentElement.dataset.theme=printed;printed=null;}});})();`;
 
 /**
  * Keep an embedded Scalar reference on Blume's theme. Scalar picks its own

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

@@ -500,6 +500,12 @@ export interface ThemeConfig {
   mode?: "system" | "light" | "dark";
   /** Corner radius scale. Defaults to `md`. */
   radius?: RadiusScale;
+  /**
+   * Show the header's light/dark toggle. Defaults to `true`. `false` hides it
+   * and ignores any choice a reader saved earlier, so every page renders in
+   * `mode` (`system` follows the reader's OS setting).
+   */
+  toggle?: boolean;
 }
 
 // ---------------------------------------------------------------------------
@@ -1099,6 +1105,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 +1235,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 +1296,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,