@brandon_m_behring/book-scaffold-astro 4.28.0 → 4.30.0

package/scripts/authored-links.mjs

@@ -0,0 +1,328 @@
+/**
+ * Structural authored-link discovery for `book-scaffold validate` (#190).
+ *
+ * Markdown and MDX are parsed into their real syntax trees so code examples,
+ * comments, nested labels, JSX expressions, and literal decoding follow the
+ * same grammar as the rendered book. Raw HTML is parsed only from ranges that
+ * the Markdown AST identified as HTML. This module never rewrites content.
+ */
+import { parseFragment } from 'parse5';
+import remarkMath from 'remark-math';
+import remarkMdx from 'remark-mdx';
+import remarkParse from 'remark-parse';
+import { unified } from 'unified';
+
+const ORIGIN = 'https://book-scaffold.invalid';
+const processors = new Map();
+
+/** Normalize the portion of Astro's `base` relevant to containment checks. */
+export function normalizeAstroBase(base = '/') {
+  const value = typeof base === 'string' && base.length > 0 ? base : '/';
+  const withLeadingSlash = value.startsWith('/') ? value : `/${value}`;
+  const pathname = new URL(withLeadingSlash, ORIGIN).pathname;
+  return pathname.replace(/\/+$/, '') || '/';
+}
+
+/**
+ * Parse a browser-rooted same-origin target. A single leading backslash is
+ * included because WHATWG HTTP URL parsing treats it as a root slash. True
+ * protocol-relative URLs and inputs that resolve onto another host are not
+ * internal authored targets.
+ */
+function rootTargetUrl(target) {
+  if (typeof target !== 'string') return null;
+  const value = target.trim();
+  if (!value.startsWith('/') && !value.startsWith('\\')) return null;
+  if (value.startsWith('//') || value.startsWith('\\\\')) return null;
+
+  try {
+    const url = new URL(value, ORIGIN);
+    return url.origin === ORIGIN ? url : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Browser-normalized pathname for a same-origin root target, else null. */
+export function rootTargetPathname(target) {
+  const url = rootTargetUrl(target);
+  return url ? url.pathname.replace(/\/+$/, '') || '/' : null;
+}
+
+/**
+ * True only for a same-origin root target outside `base`.
+ * Protocols, protocol-relative URLs, fragments, relative URLs, and targets
+ * already under the configured base all return false.
+ */
+export function rootTargetEscapesBase(target, base) {
+  const normalizedBase = normalizeAstroBase(base);
+  if (normalizedBase === '/') return false;
+
+  const pathname = rootTargetPathname(target);
+  if (pathname === null) return false;
+  return pathname !== normalizedBase && !pathname.startsWith(`${normalizedBase}/`);
+}
+
+/**
+ * Return a browser-normalized, base-contained suggestion for a violating
+ * target. Normalizing before prefixing prevents `..` (including percent-
+ * encoded dot segments) from escaping the base a second time.
+ */
+export function suggestBaseContainedTarget(target, base) {
+  const normalizedBase = normalizeAstroBase(base);
+  const url = rootTargetUrl(target);
+  if (!url) return target;
+  const prefix = normalizedBase === '/' ? '' : normalizedBase;
+  return `${prefix}${url.pathname}${url.search}${url.hash}`;
+}
+
+function blankFrontmatter(content) {
+  return content.replace(
+    /^\uFEFF?---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*(?:\r?\n|$)/,
+    (match) => match.replace(/[^\r\n]/g, ' '),
+  );
+}
+
+function processorFor(format, math) {
+  const key = `${format}:${math ? 'math' : 'plain'}`;
+  if (!processors.has(key)) {
+    const processor = unified().use(remarkParse);
+    if (format === 'mdx') processor.use(remarkMdx);
+    // Math syntax is profile-dependent. Enabling it for every book would hide
+    // real links authored between dollar signs in non-math profiles.
+    if (math) processor.use(remarkMath);
+    processors.set(key, processor);
+  }
+  return processors.get(key);
+}
+
+function positionStart(node) {
+  return node?.position?.start?.offset ?? 0;
+}
+
+function attributeValueOffset(source, start, end) {
+  const attribute = source.slice(start, end);
+  const equals = attribute.indexOf('=');
+  if (equals < 0) return start;
+
+  let offset = equals + 1;
+  while (/\s/.test(attribute[offset] ?? '')) offset += 1;
+  if (attribute[offset] === '"' || attribute[offset] === "'") offset += 1;
+  return start + offset;
+}
+
+function markdownDestinationOffset(node, source) {
+  const start = positionStart(node);
+  const end = node?.position?.end?.offset ?? start;
+  const authored = source.slice(start, end);
+  const marker = node.type === 'definition' ? authored.lastIndexOf(']:') : authored.lastIndexOf('](');
+  if (marker < 0) return start;
+
+  let offset = marker + 2;
+  while (/\s/.test(authored[offset] ?? '')) offset += 1;
+  if (authored[offset] === '<') offset += 1;
+  return start + offset;
+}
+
+function literalMdxAttribute(attribute, source) {
+  if (typeof attribute.value === 'string') {
+    return {
+      target: attribute.value,
+      index: attributeValueOffset(
+        source,
+        positionStart(attribute),
+        attribute.position?.end?.offset ?? positionStart(attribute),
+      ),
+    };
+  }
+
+  if (attribute.value?.type !== 'mdxJsxAttributeValueExpression') return null;
+  const program = attribute.value.data?.estree;
+  if (program?.body?.length !== 1 || program.body[0]?.type !== 'ExpressionStatement') return null;
+  const expression = program.body[0].expression;
+
+  if (expression?.type === 'Literal' && typeof expression.value === 'string') {
+    return { target: expression.value, index: expression.start ?? positionStart(attribute) };
+  }
+  if (
+    expression?.type === 'TemplateLiteral' &&
+    expression.expressions?.length === 0 &&
+    expression.quasis?.length === 1 &&
+    typeof expression.quasis[0].value?.cooked === 'string'
+  ) {
+    return {
+      target: expression.quasis[0].value.cooked,
+      index: expression.quasis[0].start ?? expression.start ?? positionStart(attribute),
+    };
+  }
+  return null;
+}
+
+/**
+ * Resolve one JSX prop in source order. A later explicit literal overrides an
+ * earlier spread, while a later spread or dynamic expression makes the final
+ * runtime value unknowable. This mirrors JSX object-spread semantics.
+ */
+function literalMdxProp(element, name, source) {
+  let result = null;
+  for (const attribute of element.attributes ?? []) {
+    if (attribute.type === 'mdxJsxExpressionAttribute') {
+      result = null;
+      continue;
+    }
+    if (
+      attribute.type !== 'mdxJsxAttribute' ||
+      typeof attribute.name !== 'string' ||
+      attribute.name.toLowerCase() !== name
+    ) {
+      continue;
+    }
+    result = literalMdxAttribute(attribute, source);
+  }
+  return result;
+}
+
+function htmlSourceFromRanges(source, ranges) {
+  const chars = new Array(source.length);
+  for (let i = 0; i < source.length; i += 1) {
+    chars[i] = source[i] === '\n' || source[i] === '\r' ? source[i] : ' ';
+  }
+  for (const [start, end] of ranges) {
+    for (let i = start; i < end; i += 1) chars[i] = source[i];
+  }
+  return chars.join('');
+}
+
+function collectParsedHtmlTargets(source, ranges, add) {
+  if (ranges.length === 0) return;
+  const htmlSource = htmlSourceFromRanges(source, ranges);
+  const tree = parseFragment(htmlSource, { sourceCodeLocationInfo: true });
+
+  const visit = (node, insideCode = false) => {
+    const tagName = typeof node.tagName === 'string' ? node.tagName.toLowerCase() : null;
+    const inCodeContainer = insideCode || tagName === 'pre' || tagName === 'code';
+
+    if (tagName && !inCodeContainer) {
+      for (const attribute of node.attrs ?? []) {
+        const name = attribute.name.toLowerCase();
+        if (name !== 'href' && name !== 'src') continue;
+        const location = node.sourceCodeLocation?.attrs?.[attribute.name];
+        const start = location?.startOffset ?? node.sourceCodeLocation?.startOffset ?? 0;
+        const end = location?.endOffset ?? start;
+        add(attribute.value, attributeValueOffset(source, start, end), `${name} attribute`);
+      }
+    }
+
+    for (const child of node.childNodes ?? []) visit(child, inCodeContainer);
+    if (node.content) visit(node.content, inCodeContainer);
+  };
+
+  visit(tree);
+}
+
+function formatFrom(options) {
+  const format = typeof options === 'string' ? options : options?.format ?? 'mdx';
+  if (format !== 'md' && format !== 'mdx') {
+    throw new TypeError(`authored link parser format must be "md" or "mdx" (got ${JSON.stringify(format)})`);
+  }
+  return format;
+}
+
+/**
+ * Return every statically knowable authored Markdown/HTML/MDX href/src target.
+ * Result indices use the original source's UTF-16 offsets and are intended for
+ * file/line diagnostics; decoded targets need not occur verbatim at that index.
+ */
+export function findAuthoredTargets(content, options = {}) {
+  if (typeof content !== 'string') throw new TypeError('authored link content must be a string');
+  const format = formatFrom(options);
+  const math = typeof options === 'object' && options?.math === true;
+  const source = blankFrontmatter(content);
+  const tree = processorFor(format, math).parse(source);
+  const targets = [];
+  const seen = new Set();
+  const rawHtmlRanges = [];
+  const referencedIdentifiers = new Set();
+  const definitions = new Map();
+
+  const add = (target, index, kind) => {
+    if (typeof target !== 'string') return;
+    const value = target.trim();
+    const key = `${index}:${kind}:${value}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    targets.push({ target: value, index, kind });
+  };
+
+  const visit = (node) => {
+    if (!node || typeof node !== 'object') return;
+
+    if (node.type === 'link' || node.type === 'image') {
+      const kind = node.type === 'image' ? 'Markdown image destination' : 'Markdown link destination';
+      add(node.url, markdownDestinationOffset(node, source), kind);
+    }
+
+    if (
+      (node.type === 'linkReference' || node.type === 'imageReference') &&
+      typeof node.identifier === 'string'
+    ) {
+      referencedIdentifiers.add(node.identifier);
+    }
+
+    if (node.type === 'definition' && typeof node.identifier === 'string') {
+      // CommonMark resolves duplicate labels to the first definition.
+      if (!definitions.has(node.identifier)) definitions.set(node.identifier, node);
+    }
+
+    if (node.type === 'html') {
+      const start = positionStart(node);
+      rawHtmlRanges.push([start, node.position?.end?.offset ?? start]);
+      return;
+    }
+
+    if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {
+      const name = typeof node.name === 'string' ? node.name : '';
+      if (name === 'pre' || name === 'code') return;
+      for (const attributeName of ['href', 'src']) {
+        const literal = literalMdxProp(node, attributeName, source);
+        if (literal) add(literal.target, literal.index, `${attributeName} attribute`);
+      }
+    }
+
+    // Code nodes contain source text but no rendered links. MDX expressions and
+    // ESM nodes are also opaque unless they are a parsed JSX attribute above.
+    if (
+      node.type === 'code' ||
+      node.type === 'inlineCode' ||
+      node.type === 'mdxFlowExpression' ||
+      node.type === 'mdxTextExpression' ||
+      node.type === 'mdxjsEsm'
+    ) {
+      return;
+    }
+
+    for (const child of node.children ?? []) visit(child);
+  };
+
+  visit(tree);
+  for (const identifier of referencedIdentifiers) {
+    const definition = definitions.get(identifier);
+    if (definition) {
+      add(
+        definition.url,
+        markdownDestinationOffset(definition, source),
+        'Markdown reference destination',
+      );
+    }
+  }
+  if (format === 'md') collectParsedHtmlTargets(source, rawHtmlRanges, add);
+  return targets.sort((a, b) => a.index - b.index);
+}
+
+/** Find only literal targets that browser-resolve outside `base`. */
+export function findEscapingAuthoredTargets(content, base, options = {}) {
+  if (normalizeAstroBase(base) === '/') return [];
+  return findAuthoredTargets(content, options).filter(({ target }) =>
+    rootTargetEscapesBase(target, base),
+  );
+}

package/scripts/build-labels.mjs

@@ -2,9 +2,9 @@
 /**
  * build-labels.mjs — emit src/data/labels.json for <XRef> resolution.
  *
- * Walks the consumer's `src/content/chapters/**\/*.mdx`, extracts each
- * labelable component invocation (Theorem, Figure, Section, … — see
- * `LABELABLE_TYPES` below), and assigns it an entry of the form
+ * Walks the consumer's `src/content/chapters/**\/*.mdx`, extracts every h2–h6
+ * Markdown heading plus each labelable component invocation (Theorem, Figure,
+ * Section, … — see `LABELABLE_TYPES` below), and assigns it an entry of the form
  *   { href, display: "Theorem 4.2", number: "4.2" }
  * matching the LaTeX `\cref` convention. The map is consumed by XRef.astro
  * (display + href) AND Theorem.astro (#126: `number`, so a heading auto-
@@ -25,11 +25,15 @@
  *   - tools profile: `chapter` field (number).
  *   - academic profile: `week` field (number).
  *
- * Slug used for the href: the chapter's frontmatter `slug:` if set,
- * else filename minus `.mdx`. The href shape mirrors the consumer's pages
- * router: `/chapters/<slug>#<id>`. Academic books using `[...slug].astro`
- * get the same shape since Astro slugifies filenames identically when no
- * frontmatter override is present.
+ * Chapter IDs use frontmatter `slug:` when set, else the chapter-relative path
+ * minus `.md`/`.mdx` (so nested content IDs preserve their directory). Hrefs
+ * are resolved through the evaluated defineBookConfig `chapterRoute` and
+ * `bookField`; the default remains `chapters/<id>#<label>`.
+ *
+ * Heading anchors come from Astro's own Markdown processor, including its
+ * smartypants text normalization and GitHubSlugger duplicate suffixes. h1 is
+ * intentionally excluded because it is the chapter title, not an in-chapter
+ * BookLink target.
  *
  * Optional override:
  *   <Theorem id="…" label="Custom display" />
@@ -45,7 +49,9 @@
  * Designed to run in <2 s on a medium book.
  */
 import { readFile, writeFile, mkdir, readdir } from 'node:fs/promises';
-import { resolve, relative, join, basename, dirname } from 'node:path';
+import { resolve, relative, join, dirname, sep } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createMarkdownProcessor } from '@astrojs/markdown-remark';
 import { readChaptersBase } from './walk-mdx.mjs';
 import { loadResolvedBookConfig } from './resolve-book-config.mjs';
 // #126: reuse the ONE kind vocabulary (theorem-label.ts → its own lean tsup
@@ -54,13 +60,16 @@ import { loadResolvedBookConfig } from './resolve-book-config.mjs';
 // throw as the render path, #121) one build step earlier. Requires `dist/`
 // (run `npm run build` first; the published tarball ships dist + scripts).
 import { theoremLabel } from '../dist/lib/theorem-label.mjs';
+// #147: reuse the same route-token resolver as Sidebar/ChapterNav rather than
+// maintaining a second, hardcoded `chapters/<slug>` interpretation here.
+import { chapterHref } from '../dist/lib/nav-href.mjs';
 
 // --help / -h: non-mutating (closes #14).
 const USAGE = `Usage: book-scaffold build-labels
 
-Emit src/data/labels.json for <XRef> resolution. Walks chapter MDX files,
-extracts labelable components (Theorem, Figure, ...), assigns display strings
-like "Theorem 4.2" matching LaTeX \\cref.
+Emit src/data/labels.json for <XRef> and <BookLink> resolution. Walks chapter
+Markdown/MDX files, indexes h2–h6 anchors, and extracts labelable components
+(Theorem, Figure, ...) with display strings like "Theorem 4.2".
 
 Env:
   BOOK_CHAPTERS_DIR   Override chapters dir (default: src/content/chapters).
@@ -69,8 +78,8 @@ Env:
 Options:
   --help, -h          Print this message and exit (non-mutating).
 
-Numbering is read from defineBookConfig / defineStyle numberStyle. It defaults
-to shared when no scaffold integration can be resolved.
+Numbering and chapter hrefs are read from evaluated defineBookConfig metadata.
+Defaults are shared numbering and /chapters/:id/ when no integration resolves.
 `;
 
 if (process.argv.includes('--help') || process.argv.includes('-h')) {
@@ -111,12 +120,14 @@ const TYPE_DISPLAY = {
 
 // ===== Frontmatter parsing =====
 
-function parseFrontmatter(source) {
+function splitFrontmatter(source) {
   // Standard MDX/YAML frontmatter: `---\n…\n---`.
-  const m = source.match(/^---\n([\s\S]*?)\n---/);
-  if (!m) return {};
+  // Remove it before Markdown processing: YAML comments beginning with `#`
+  // must not become phantom headings.
+  const m = source.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!m) return { frontmatter: {}, body: source };
   const fm = {};
-  for (const line of m[1].split('\n')) {
+  for (const line of m[1].split(/\r?\n/)) {
     const kv = line.match(/^(\w+)\s*:\s*(.+?)\s*$/);
     if (!kv) continue;
     const [, key, raw] = kv;
@@ -125,7 +136,7 @@ function parseFrontmatter(source) {
     if (/^-?\d+$/.test(val)) val = parseInt(val, 10);
     fm[key] = val;
   }
-  return fm;
+  return { frontmatter: fm, body: source.slice(m[0].length) };
 }
 
 function chapterNumberOf(frontmatter) {
@@ -187,9 +198,13 @@ async function walkChapters(dir) {
 
 async function main() {
   const cwd = process.cwd();
-  const { numberStyle } = await loadResolvedBookConfig(cwd);
+  const { numberStyle, chapterRoute, bookField } = await loadResolvedBookConfig(cwd);
   const chaptersDir = resolve(cwd, CHAPTERS_DIR);
   const files = await walkChapters(chaptersDir);
+  // Syntax highlighting cannot affect heading metadata and is expensive to
+  // initialize. Everything that does affect Astro heading text/IDs (GFM,
+  // smartypants, rehypeHeadingIds/GitHubSlugger) retains Astro's defaults.
+  const headingProcessor = await createMarkdownProcessor({ syntaxHighlight: false });
 
   const labels = {};
   const tagRegex = buildTagRegex();
@@ -198,16 +213,63 @@ async function main() {
 
   for (const file of files) {
     const source = await readFile(file, 'utf8');
-    const fm = parseFrontmatter(source);
+    const { frontmatter: fm, body } = splitFrontmatter(source);
     const chapterNum = chapterNumberOf(fm);
-    const slug = (typeof fm.slug === 'string' && fm.slug.length > 0)
+    const contentId = relative(chaptersDir, file)
+      .split(sep)
+      .join('/')
+      .replace(/\.mdx?$/, '');
+    const entryId = (typeof fm.slug === 'string' && fm.slug.length > 0)
       ? fm.slug
-      : basename(file).replace(/\.mdx?$/, '');
+      : contentId;
+    const chapterPath = chapterHref(
+      { id: entryId, data: fm },
+      chapterRoute,
+      '/',
+      bookField,
+    ).replace(/^\/+|\/+$/g, '');
+
+    const addLabel = (id, value) => {
+      if (labels[id]) {
+        // Duplicate id — surface but don't fail; consumer's validator catches
+        // collisions with full diagnostic context. Component IDs retain their
+        // historical precedence over an identically named heading anchor.
+        process.stderr.write(
+          `build-labels: WARN duplicate id "${id}" (first in ` +
+            `${labels[id].href.split('#')[0]}, now in ${entryId})\n`,
+        );
+      }
+      labels[id] = value;
+    };
 
     // Per-chapter counters reset for each file.
     const counters = {};
     let foundInChapter = 0;
 
+    // #147: BookLink fragments normally target prose sections rather than
+    // labelable components. Astro owns both text extraction and GitHub-style
+    // slug collision behavior, so consume its heading metadata directly.
+    const rendered = await headingProcessor.render(body, {
+      fileURL: pathToFileURL(file),
+      frontmatter: fm,
+    });
+    for (const heading of rendered.metadata.headings) {
+      if (heading.depth < 2 || heading.depth > 6) continue;
+      foundInChapter += 1;
+      totalIds += 1;
+      const href = `${chapterPath}#${heading.slug}`;
+      // Heading fragments are only document-local: many chapters legitimately
+      // contain `#summary`. A path-qualified, opaque key preserves every one
+      // without colliding with component IDs or another chapter. BookLink
+      // validation resolves the exact href VALUE; consumers must not derive
+      // heading semantics from this internal key.
+      addLabel(`heading:${href}`, {
+        href,
+        display: heading.text,
+        number: null,
+      });
+    }
+
     for (const match of source.matchAll(tagRegex)) {
       const [, componentName, attrs] = match;
       const id = extractAttr(attrs, 'id');
@@ -267,21 +329,13 @@ async function main() {
           : String(counters[counterKey]);
       const display = labelOverride ?? `${word} ${number}`;
 
-      if (labels[id]) {
-        // Duplicate id — surface but don't fail; consumer's validator
-        // catches collisions with full diagnostic context.
-        process.stderr.write(
-          `build-labels: WARN duplicate id "${id}" (first in ` +
-            `${labels[id].href.split('#')[0]}, now in ${slug})\n`,
-        );
-      }
-      labels[id] = {
+      addLabel(id, {
         // #142: base-less ref — XRef.astro prefixes BASE_URL at render so one
         // labels.json serves any deploy base (root or path-proxied series).
-        href: `chapters/${slug}#${id}`,
+        href: `${chapterPath}#${id}`,
         display,
         number,
-      };
+      });
     }
 
     if (foundInChapter > 0) chaptersWithIds += 1;

package/scripts/resolve-book-config.mjs

@@ -5,6 +5,10 @@ import { loadConfigFromFile } from 'vite';
 export const DEFAULT_TOOLING_CONFIG = Object.freeze({
   preset: null,
   numberStyle: 'shared',
+  siblingBooks: Object.freeze({}),
+  chapterRoute: '/chapters/:id/',
+  bookField: 'book',
+  base: '/',
   integrationFound: false,
 });
 
@@ -42,6 +46,75 @@ function assertPreset(value, configPath) {
   }
 }
 
+function resolveNonEmptyString(value, fallback, field, configPath) {
+  if (value == null) return fallback;
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(
+      `book-scaffold tooling: ${configPath} resolved invalid ${field} ` +
+        `${JSON.stringify(value)}; expected a non-empty string.`,
+    );
+  }
+  return value;
+}
+
+function resolveBase(value, configPath) {
+  if (value == null || value === '') return '/';
+  if (typeof value !== 'string') {
+    throw new Error(
+      `book-scaffold tooling: ${configPath} resolved invalid Astro base ` +
+        `${JSON.stringify(value)}; expected a string.`,
+    );
+  }
+  return value;
+}
+
+function resolveSiblingBooks(value, configPath) {
+  if (value == null) return {};
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(
+      `book-scaffold tooling: ${configPath} resolved invalid siblingBooks ` +
+        `${JSON.stringify(value)}; expected an object registry.`,
+    );
+  }
+
+  const resolved = [];
+  for (const [book, entry] of Object.entries(value)) {
+    if (typeof entry === 'string') {
+      if (entry.length === 0) {
+        throw new Error(
+          `book-scaffold tooling: ${configPath} resolved invalid siblingBooks.${book}; ` +
+            'URL strings must not be empty.',
+        );
+      }
+      resolved.push([book, entry]);
+      continue;
+    }
+
+    if (
+      entry === null ||
+      typeof entry !== 'object' ||
+      Array.isArray(entry) ||
+      typeof entry.url !== 'string' ||
+      entry.url.length === 0 ||
+      (entry.labels !== undefined &&
+        (typeof entry.labels !== 'string' || entry.labels.length === 0))
+    ) {
+      throw new Error(
+        `book-scaffold tooling: ${configPath} resolved invalid siblingBooks.${book}; ` +
+          'expected a URL string or { url: string, labels?: string }.',
+      );
+    }
+    resolved.push([
+      book,
+      {
+        url: entry.url,
+        ...(entry.labels === undefined ? {} : { labels: entry.labels }),
+      },
+    ]);
+  }
+  return Object.fromEntries(resolved);
+}
+
 /**
  * Evaluate the consumer's actual Astro config and read the scaffold
  * integration's internal resolved metadata. Absence of a config/integration is
@@ -74,15 +147,16 @@ export async function loadResolvedBookConfig(projectRoot = process.cwd()) {
   const integrations = Array.isArray(loaded.config?.integrations)
     ? loaded.config.integrations.flat(Infinity)
     : [];
+  const base = resolveBase(loaded.config?.base, configPath);
   const integration = integrations.find((candidate) => candidate?.name === 'book-scaffold-astro');
-  if (!integration) return { ...DEFAULT_TOOLING_CONFIG };
+  if (!integration) return { ...DEFAULT_TOOLING_CONFIG, base };
 
   const metadata = integration.__bookScaffoldResolvedConfig;
   if (!metadata) {
     // A config can contain an older scaffold integration with no metadata.
     // Preserve the historical numbering default rather than treating upgrade
     // sequencing as a config error.
-    return { ...DEFAULT_TOOLING_CONFIG, integrationFound: true };
+    return { ...DEFAULT_TOOLING_CONFIG, base, integrationFound: true };
   }
 
   const numberStyle = metadata.numberStyle ?? 'shared';
@@ -91,6 +165,20 @@ export async function loadResolvedBookConfig(projectRoot = process.cwd()) {
   return {
     preset: metadata.preset ?? null,
     numberStyle,
+    siblingBooks: resolveSiblingBooks(metadata.siblingBooks, configPath),
+    chapterRoute: resolveNonEmptyString(
+      metadata.chapterRoute,
+      DEFAULT_TOOLING_CONFIG.chapterRoute,
+      'chapterRoute',
+      configPath,
+    ),
+    bookField: resolveNonEmptyString(
+      metadata.bookField,
+      DEFAULT_TOOLING_CONFIG.bookField,
+      'bookField',
+      configPath,
+    ),
+    base,
     integrationFound: true,
   };
 }