@abreen/tada 1.17.1 → 1.18.1

package/build/config-loader.ts

@@ -1,5 +1,5 @@
 import fs from 'fs';
-import _ from 'lodash';
+import { compileTemplate } from './lodash-template';
 import {
   resolveProjectConfigFile,
   resolveSiteConfigFile,
@@ -44,7 +44,7 @@ function renderConfigTemplateString(
   fileName: string,
 ): string {
   try {
-    return _.template(value)(context);
+    return compileTemplate(value)(context);
   } catch (error) {
     throw new Error(
       `${fileName}: Lodash template error in config: ${getTemplateErrorMessage(error)}`,
@@ -61,7 +61,7 @@ function evaluateConfigTemplateExpression(
   let captured: unknown;
 
   try {
-    _.template(`<% __capture(( ${expression} )); %>`)({
+    compileTemplate(`<% __capture(( ${expression} )); %>`)({
       ...context,
       __capture(value: unknown) {
         captured = value;

package/build/custom-fonts.ts

@@ -41,14 +41,17 @@ interface CustomFontValidationOptions {
 }
 
 export function isValidPublicWoff2Path(filePath: string): boolean {
+  return isValidPublicAssetPath(filePath) && filePath.endsWith('.woff2');
+}
+
+export function isValidPublicAssetPath(filePath: string): boolean {
   if (
     filePath.length === 0 ||
     filePath.startsWith('/') ||
     /^[A-Za-z]:/.test(filePath) ||
     filePath.includes('\\') ||
     filePath.includes('?') ||
-    filePath.includes('#') ||
-    !filePath.endsWith('.woff2')
+    filePath.includes('#')
   ) {
     return false;
   }
@@ -160,7 +163,7 @@ export function renderCustomFontTuningScss(
     serifTuning?.lineHeight !== undefined
   ) {
     rules.push(
-      `  ${rootSelector} main.body > :is(footer, .appearance-pickers, .slides-header, .file-header) {\n    font-size: var(--font-size);\n    line-height: var(--line-height);\n  }`,
+      `  ${rootSelector} main.body .page-bottom, ${rootSelector} main.body > .page-content > :is(.slides-header, .file-header) {\n    font-size: var(--font-size);\n    line-height: var(--line-height);\n  }`,
     );
   }
 
@@ -206,7 +209,7 @@ export function renderCustomFontTuningScss(
 export function getSerifFontStack(
   fontOverrides: FontOverrides | undefined,
 ): string {
-  const custom = fontOverrides?.serif
+  const custom = fontOverrides?.serif?.regular
     ? `'${CUSTOM_FONT_FAMILY_DEFINITIONS.serif.cssFamily}', `
     : '';
   return `${custom}'Source Serif 4', 'Times New Roman', 'Times', serif`;
@@ -215,7 +218,7 @@ export function getSerifFontStack(
 export function getSerifMonoFontStack(
   fontOverrides: FontOverrides | undefined,
 ): string {
-  const custom = fontOverrides?.serifMono
+  const custom = fontOverrides?.serifMono?.regular
     ? `'${CUSTOM_FONT_FAMILY_DEFINITIONS.serifMono.cssFamily}', `
     : '';
   return `${custom}'Courier Prime', 'Courier New', 'Courier', monospace`;

package/build/generate-favicon.ts

@@ -1,4 +1,3 @@
-import fs from 'fs';
 import path from 'path';
 import * as fontkit from 'fontkit';
 import sharp from 'sharp';
@@ -108,10 +107,11 @@ function createFaviconSvg(
 </svg>`;
 }
 
+/** Generated favicon files, keyed by output path */
 export async function generateFavicons(
   siteVariables: SiteVariables,
-  distDir: string,
-): Promise<void> {
+): Promise<Map<string, string | Uint8Array>> {
+  const outputs = new Map<string, string | Uint8Array>();
   const color = siteVariables.faviconColor!;
   const symbol = siteVariables.faviconSymbol!;
   const fontWeight = siteVariables.faviconFontWeight || 700;
@@ -132,7 +132,7 @@ export async function generateFavicons(
     font,
     fontWeight,
   );
-  fs.writeFileSync(path.join(distDir, `${filenameBase}.svg`), svgMarkup);
+  outputs.set(`${filenameBase}.svg`, svgMarkup);
 
   const pngBuffers = await Promise.all(
     FAVICON_SIZES.map(async size => {
@@ -145,7 +145,7 @@ export async function generateFavicons(
         fontWeight,
       );
       const buf = await sharp(Buffer.from(svgForSize)).png().toBuffer();
-      fs.writeFileSync(path.join(distDir, `${filenameBase}-${size}.png`), buf);
+      outputs.set(`${filenameBase}-${size}.png`, buf);
       return { size, buf };
     }),
   );
@@ -156,5 +156,6 @@ export async function generateFavicons(
       .sort((a, b) => a.size - b.size)
       .map(x => x.buf),
   );
-  fs.writeFileSync(path.join(distDir, `${filenameBase}.ico`), icoBuffer);
+  outputs.set(`${filenameBase}.ico`, icoBuffer);
+  return outputs;
 }

package/build/generate-fonts.ts

@@ -1,10 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import { getPackageDir } from './utils/paths';
-import { makeLogger } from './log';
-import type { SiteVariables } from './types';
+import type { CopiedFile, SiteVariables } from './types';
 
-const log = makeLogger(import.meta.url);
 const FONTS_DIR = path.join(getPackageDir(), 'fonts');
 
 export const DEFAULT_FONT_PRELOAD_FILES = {
@@ -49,26 +47,21 @@ export function getDefaultFontPreloadFiles(
   ];
 }
 
-export function copyFonts(distDir: string): void {
-  log.info`Copying fonts`;
-
+/** Bundled browser fonts, as copy references keyed by output path */
+export function getFontOutputs(): Map<string, CopiedFile> {
+  const outputs = new Map<string, CopiedFile>();
   for (const family of fs.readdirSync(FONTS_DIR)) {
     const woff2Dir = path.join(FONTS_DIR, family, 'woff2');
     if (!fs.existsSync(woff2Dir) || !fs.statSync(woff2Dir).isDirectory()) {
       continue;
     }
-
-    const outFamilyDir = path.join(distDir, family);
-    fs.mkdirSync(outFamilyDir, { recursive: true });
-
     for (const file of fs.readdirSync(woff2Dir)) {
       if (file.endsWith('.woff2')) {
-        fs.copyFileSync(
-          path.join(woff2Dir, file),
-          path.join(outFamilyDir, file),
-        );
-        log.debug`Copied ${family}/${file}`;
+        outputs.set(`${family}/${file}`, {
+          copyFrom: path.join(woff2Dir, file),
+        });
       }
     }
   }
+  return outputs;
 }

package/build/generate-katex-assets.ts

@@ -1,35 +1,37 @@
 import fs from 'fs';
 import path from 'path';
 import * as sass from 'sass';
-import { makeLogger } from './log';
+import type { OutputContent } from './types';
 
-const log = makeLogger(import.meta.url);
-
-export function copyKatexAssets(distDir: string): void {
-  log.info`Copying KaTeX assets`;
-
-  const outDir = path.join(distDir, 'katex');
-  const outFontsDir = path.join(outDir, 'fonts');
-  fs.mkdirSync(outFontsDir, { recursive: true });
+let katexCss: string | undefined;
 
+function compileKatexCss(): string {
   // Compile KaTeX SCSS with woff2-only font references
   const katexScssDir = path.dirname(
     require.resolve('katex/src/styles/katex.scss'),
   );
-  const result = sass.compileString(
+  return sass.compileString(
     `@use 'katex' with ($use-woff2: true, $use-woff: false, $use-ttf: false, $font-folder: 'fonts');`,
     { loadPaths: [katexScssDir], style: 'compressed' },
-  );
-  fs.writeFileSync(path.join(outDir, 'katex.min.css'), result.css);
+  ).css;
+}
 
-  // Copy woff2 fonts
-  const katexDistDir = path.dirname(
-    require.resolve('katex/dist/katex.min.css'),
+/** The KaTeX stylesheet and its woff2 fonts, keyed by output path */
+export function getKatexOutputs(): Map<string, OutputContent> {
+  katexCss ??= compileKatexCss();
+  const outputs = new Map<string, OutputContent>([
+    ['katex/katex.min.css', katexCss],
+  ]);
+  const fontsDir = path.join(
+    path.dirname(require.resolve('katex/dist/katex.min.css')),
+    'fonts',
   );
-  const fontsDir = path.join(katexDistDir, 'fonts');
   for (const file of fs.readdirSync(fontsDir)) {
     if (file.endsWith('.woff2')) {
-      fs.copyFileSync(path.join(fontsDir, file), path.join(outFontsDir, file));
+      outputs.set(`katex/fonts/${file}`, {
+        copyFrom: path.join(fontsDir, file),
+      });
     }
   }
+  return outputs;
 }

package/build/generate-web-app-manifest.ts

@@ -1,5 +1,3 @@
-import fs from 'fs';
-import path from 'path';
 import { createApplyBasePath } from './util';
 import { FAVICON_SIZES } from './generate-favicon';
 import type { SiteVariables } from './types';
@@ -57,13 +55,7 @@ function createManifest(siteVariables: SiteVariables): WebAppManifest {
   };
 }
 
-export function generateWebAppManifest(
-  siteVariables: SiteVariables,
-  distDir: string,
-): void {
-  const manifest = createManifest(siteVariables);
-  fs.writeFileSync(
-    path.join(distDir, 'manifest.json'),
-    JSON.stringify(manifest),
-  );
+/** The web app manifest (`manifest.json`) for generated favicons */
+export function createWebAppManifest(siteVariables: SiteVariables): string {
+  return JSON.stringify(createManifest(siteVariables));
 }

package/build/lodash-template.ts

@@ -0,0 +1,14 @@
+import _ from 'lodash';
+
+/**
+ * Compiles a Lodash template that only recognizes `<% %>`, `<%= %>`, and
+ * `<%- %>` delimiters.
+ *
+ * Lodash also treats ES template literal syntax (`${expr}`) as interpolation,
+ * but only while `interpolate` is its built-in regex object. Passing a separate
+ * regex literal with the same pattern disables that, so `${...}` in Markdown,
+ * code samples, and source files stays literal text.
+ */
+export function compileTemplate(source: string): _.TemplateExecutor {
+  return _.template(source, { interpolate: /<%=([\s\S]+?)%>/g });
+}

package/build/material-symbols.ts

@@ -48,10 +48,13 @@ export const MATERIAL_SYMBOLS = Object.freeze({
     symbol: 'warning',
     opticalSize: 20,
   }),
-  parent: Object.freeze({
-    cssVariable: '--icon-parent',
-    symbol: 'south_east',
-    opticalSize: 20,
+  breadcrumbSeparator: Object.freeze({
+    cssVariable: '--icon-breadcrumb-separator',
+    symbol: 'chevron_right',
+    opticalSize: 24,
+    // The authored selection differs from the shared weight/grade defaults.
+    weight: 400,
+    grade: 0,
   }),
   search: Object.freeze({
     cssVariable: '--icon-search',

package/build/output-publication.ts

@@ -0,0 +1,238 @@
+import fs from 'fs';
+import path from 'path';
+import { globals } from './globals';
+import { toPosix } from './utils/paths';
+import type { OutputContent } from './types';
+
+type FileMutation =
+  | { kind: 'write'; path: string; content: OutputContent }
+  | { kind: 'delete'; path: string };
+
+/** An output file and the source that produced it */
+export interface OutputFile {
+  sourcePath: string;
+  content: OutputContent;
+}
+
+// EBUSY means a file is briefly held open. On Windows, EPERM and EACCES also
+// mean that (an indexer, antivirus, or the dev server holding the file); on
+// other platforms they are permanent permission errors and are not retried.
+const BUSY_ERROR_CODES = new Set(
+  process.platform === 'win32' ? ['EBUSY', 'EPERM', 'EACCES'] : ['EBUSY'],
+);
+const BUSY_RETRY_COUNT = 4;
+const BUSY_RETRY_DELAY_MS = 50;
+
+function retryWhileBusy(action: () => void): void {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      action();
+      return;
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (attempt >= BUSY_RETRY_COUNT || !code || !BUSY_ERROR_CODES.has(code)) {
+        throw error;
+      }
+      globals.sleepSync(BUSY_RETRY_DELAY_MS);
+    }
+  }
+}
+
+/** Writes rendered text or bytes, or copies a referenced source file. */
+export function writeOutputFile(
+  filePath: string,
+  content: OutputContent,
+): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  // Older builds may have copied a source's read-only permissions.
+  if (fs.lstatSync(filePath, { throwIfNoEntry: false })?.isFile()) {
+    fs.chmodSync(filePath, 0o644);
+  }
+  if (typeof content === 'string' || content instanceof Uint8Array) {
+    fs.writeFileSync(filePath, content);
+  } else {
+    fs.copyFileSync(content.copyFrom, filePath);
+    // Distribution output is writable regardless of the source permissions.
+    fs.chmodSync(filePath, 0o644);
+  }
+}
+
+export function sameOutputContent(
+  left: OutputContent,
+  right: OutputContent,
+): boolean {
+  if (typeof left === 'string' || typeof right === 'string') {
+    return left === right;
+  }
+  if (left instanceof Uint8Array || right instanceof Uint8Array) {
+    return (
+      left instanceof Uint8Array &&
+      right instanceof Uint8Array &&
+      Buffer.compare(left, right) === 0
+    );
+  }
+  // Copied files compare by source path; a source whose contents changed is
+  // always rebuilt, which forces a write.
+  return left.copyFrom === right.copyFrom;
+}
+
+/**
+ * Mutations from one build's outputs to the next. Outputs from a source in
+ * `forceSourcePaths` are rewritten even when they look unchanged.
+ */
+export function computeMutations(
+  previous: ReadonlyMap<string, OutputFile>,
+  next: ReadonlyMap<string, OutputFile>,
+  forceSourcePaths: ReadonlySet<string> = new Set(),
+): FileMutation[] {
+  const mutations: FileMutation[] = [];
+  for (const outputPath of new Set([...previous.keys(), ...next.keys()])) {
+    const before = previous.get(outputPath);
+    const after = next.get(outputPath);
+    if (!after) {
+      mutations.push({ kind: 'delete', path: outputPath });
+    } else if (
+      !before ||
+      !sameOutputContent(before.content, after.content) ||
+      forceSourcePaths.has(after.sourcePath)
+    ) {
+      mutations.push({
+        kind: 'write',
+        path: outputPath,
+        content: after.content,
+      });
+    }
+  }
+  return mutations;
+}
+
+/**
+ * Mutations that make `rootDir` hold exactly `outputs`: every output is
+ * written, and every other file and empty directory is deleted except those
+ * under `keep`.
+ */
+export function planFullWrite(
+  rootDir: string,
+  outputs: ReadonlyMap<string, OutputFile>,
+  keep: readonly string[] = [],
+): FileMutation[] {
+  const files: string[] = [];
+  const dirs: string[] = [];
+  // Walk one level at a time: a recursive listing would follow symbolic links
+  // to directories. A link is listed as a file, so deleting it removes only
+  // the link, never what it points to.
+  const walk = (dir: string): void => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path.join(dir, entry.name);
+      const relPath = toPosix(path.relative(rootDir, fullPath));
+      if (entry.isDirectory()) {
+        dirs.push(relPath);
+        walk(fullPath);
+      } else {
+        files.push(relPath);
+      }
+    }
+  };
+  if (fs.existsSync(rootDir)) {
+    walk(rootDir);
+  }
+  const isKept = (relPath: string) =>
+    keep.some(prefix => `${relPath}/`.startsWith(prefix));
+  const dirsWithFiles = new Set<string>();
+  for (const file of files) {
+    const segments = file.split('/');
+    for (let i = 1; i < segments.length; i++) {
+      dirsWithFiles.add(segments.slice(0, i).join('/'));
+    }
+  }
+
+  const deletes: FileMutation[] = [
+    ...files.filter(file => !isKept(file) && !outputs.has(file)),
+    ...dirs.filter(dir => !isKept(dir) && !dirsWithFiles.has(dir)),
+  ].map(relPath => ({ kind: 'delete', path: relPath }));
+  const writes: FileMutation[] = [...outputs].map(([outputPath, output]) => ({
+    kind: 'write',
+    path: outputPath,
+    content: output.content,
+  }));
+  return [...deletes, ...writes];
+}
+
+function pruneEmptyDirs(rootDir: string, filePath: string): void {
+  const root = path.resolve(rootDir);
+  for (
+    let dir = path.dirname(filePath);
+    dir !== root;
+    dir = path.dirname(dir)
+  ) {
+    try {
+      fs.rmdirSync(dir);
+    } catch {
+      return;
+    }
+  }
+}
+
+/** Throws if a path would be reached through a symbolic link below `rootDir`. */
+function createSymlinkGuard(rootDir: string): (target: string) => void {
+  const root = path.resolve(rootDir);
+  const safeDirs = new Set<string>([root]);
+  return target => {
+    const visited: string[] = [];
+    for (
+      let dir = path.dirname(target);
+      !safeDirs.has(dir) && dir.startsWith(root + path.sep);
+      dir = path.dirname(dir)
+    ) {
+      if (fs.lstatSync(dir, { throwIfNoEntry: false })?.isSymbolicLink()) {
+        throw new Error(`Refusing to write through the symbolic link ${dir}`);
+      }
+      visited.push(dir);
+    }
+    for (const dir of visited) {
+      safeDirs.add(dir);
+    }
+  };
+}
+
+/**
+ * Applies mutations to the files in `rootDir` in place. Deletes run first,
+ * deepest paths first, and remove directories they leave empty, so an output
+ * can change between a file and a directory. Nothing is renamed, staged, or
+ * rolled back: if a write fails, the error is thrown and earlier writes stay.
+ * Nothing is written or deleted through a symbolic link.
+ */
+export function applyMutations(
+  rootDir: string,
+  mutations: readonly FileMutation[],
+): void {
+  const assertNotThroughSymlink = createSymlinkGuard(rootDir);
+  const deletes = mutations
+    .filter(mutation => mutation.kind === 'delete')
+    .sort((a, b) => b.path.length - a.path.length);
+  for (const mutation of deletes) {
+    const target = path.resolve(rootDir, mutation.path);
+    assertNotThroughSymlink(target);
+    retryWhileBusy(() => {
+      if (fs.lstatSync(target, { throwIfNoEntry: false })?.isDirectory()) {
+        fs.rmdirSync(target);
+      } else {
+        fs.rmSync(target, { force: true });
+      }
+    });
+    pruneEmptyDirs(rootDir, target);
+  }
+  for (const mutation of mutations) {
+    if (mutation.kind === 'write') {
+      const target = path.resolve(rootDir, mutation.path);
+      assertNotThroughSymlink(target);
+      retryWhileBusy(() => {
+        // Replace a link at the target itself; writing would follow it
+        if (fs.lstatSync(target, { throwIfNoEntry: false })?.isSymbolicLink()) {
+          fs.rmSync(target, { force: true });
+        }
+        writeOutputFile(target, mutation.content);
+      });
+    }
+  }
+}

package/build/pagefind.ts

@@ -1,17 +1,26 @@
+import fs from 'fs';
 import path from 'path';
 import { makeLogger } from './log';
 import { collectReachableSiteAssets } from './reachability';
-import {
-  getContentDir,
-  getFilesByExtensions,
-  normalizeOutputPath,
-} from './util';
+import { normalizeOutputPath, SEARCH_INDEX_DIR } from './utils/paths';
+import { isFeatureEnabled } from './features';
+import type { SiteVariables } from './types';
+import type { TadaProjectScan } from './source-model';
 import { assertMutoolAvailable, extractPdfPages } from './pdf-text';
 import type { HtmlOutputAnalysis } from './types';
 
 const log = makeLogger(import.meta.url);
 const PAGEFIND_VERBOSE = process.env.TADA_LOG_LEVEL === 'debug';
-const PAGEFIND_OUTPUT_SUBDIR = 'pagefind';
+
+/**
+ * Output path prefixes a full write leaves alone: the search index, which is
+ * written after the build.
+ */
+export function getKeptOutputPrefixes(siteVariables: SiteVariables): string[] {
+  return isFeatureEnabled(siteVariables, 'search')
+    ? [`${SEARCH_INDEX_DIR}/`]
+    : [];
+}
 
 type PagefindModule = typeof import('pagefind');
 type PagefindIndex = Awaited<
@@ -71,16 +80,21 @@ async function addPdfRecord(
   }
 }
 
-function getPdfSourceByOutputPath(): Map<string, string> {
-  const contentDir = getContentDir();
-  const pdfFiles: string[] = getFilesByExtensions(contentDir, ['pdf']);
-
-  return new Map(
-    pdfFiles.map((filePath: string) => {
-      const relPath = path.relative(contentDir, filePath);
-      return [normalizeOutputPath(`/${relPath}`), filePath] as const;
-    }),
-  );
+/** PDFs copied from `content/`, keyed by their root-relative output path */
+export function getPdfSources(scan: TadaProjectScan): Map<string, string> {
+  const pdfSources = new Map<string, string>();
+  for (const [filePath, entry] of scan.sources) {
+    if (
+      entry.renderKind !== 'content-copy' ||
+      path.extname(filePath).toLowerCase() !== '.pdf'
+    ) {
+      continue;
+    }
+    for (const outputPath of entry.outputs) {
+      pdfSources.set(normalizeOutputPath(`/${outputPath}`), filePath);
+    }
+  }
+  return pdfSources;
 }
 
 interface IndexTargets {
@@ -120,6 +134,13 @@ interface BuildIndexOptions {
   loadPagefind?: () => Promise<PagefindModule>;
   checkMutool?: () => Promise<void>;
   extractPages?: typeof extractPdfPages;
+  prepareOutputDir?: (dir: string) => void;
+}
+
+function prepareSearchIndexDir(dir: string): void {
+  if (fs.lstatSync(dir, { throwIfNoEntry: false })?.isFile()) {
+    fs.unlinkSync(dir);
+  }
 }
 
 async function buildIndex({
@@ -131,6 +152,7 @@ async function buildIndex({
   loadPagefind = getPagefind,
   checkMutool = assertMutoolAvailable,
   extractPages = extractPdfPages,
+  prepareOutputDir = prepareSearchIndexDir,
 }: BuildIndexOptions): Promise<void> {
   const pagefind = await loadPagefind();
   const { index, errors: createErrors } = await pagefind.createIndex({
@@ -200,9 +222,10 @@ async function buildIndex({
       }
     }
 
-    const { errors: writeErrors } = await index.writeFiles({
-      outputPath: path.join(distPath, PAGEFIND_OUTPUT_SUBDIR),
-    });
+    // Keep older hashed files available to browsers using the previous index.
+    const outputPath = path.join(distPath, SEARCH_INDEX_DIR);
+    prepareOutputDir(outputPath);
+    const { errors: writeErrors } = await index.writeFiles({ outputPath });
     const writeError = formatPagefindErrors('index.writeFiles()', writeErrors);
     if (writeError) {
       throw new Error(writeError);
@@ -216,14 +239,15 @@ interface RunPagefindOptions {
   distPath: string;
   htmlAssetsByPath: Map<string, string>;
   htmlAnalysisByPath: Map<string, HtmlOutputAnalysis>;
+  pdfSourceByOutputPath: Map<string, string>;
 }
 
 export async function runPagefind({
   distPath,
   htmlAssetsByPath,
   htmlAnalysisByPath,
+  pdfSourceByOutputPath,
 }: RunPagefindOptions): Promise<void> {
-  const pdfSourceByOutputPath = getPdfSourceByOutputPath();
   const start = Date.now();
 
   log.debug`Finding reachable pages for search index`;
@@ -258,6 +282,7 @@ export class WatchPagefindRunner {
   private distPath: string | null;
   private htmlCacheByAssetPath: Map<string, string>;
   private htmlAnalysisByPath: Map<string, HtmlOutputAnalysis>;
+  private pdfSourceByOutputPath: Map<string, string>;
 
   constructor() {
     this.watchRunInProgress = false;
@@ -265,16 +290,19 @@ export class WatchPagefindRunner {
     this.distPath = null;
     this.htmlCacheByAssetPath = new Map();
     this.htmlAnalysisByPath = new Map();
+    this.pdfSourceByOutputPath = new Map();
   }
 
   update(
     distPath: string,
     htmlAssetsByPath: Map<string, string>,
     htmlAnalysisByPath: Map<string, HtmlOutputAnalysis>,
+    pdfSourceByOutputPath: Map<string, string>,
   ): void {
     this.distPath = distPath;
     this.htmlCacheByAssetPath = htmlAssetsByPath;
     this.htmlAnalysisByPath = htmlAnalysisByPath;
+    this.pdfSourceByOutputPath = pdfSourceByOutputPath;
   }
 
   run(): void {
@@ -289,7 +317,7 @@ export class WatchPagefindRunner {
     const distPath = this.distPath!;
     const htmlAssetsByPath = new Map(this.htmlCacheByAssetPath);
     const htmlAnalysisByPath = new Map(this.htmlAnalysisByPath);
-    const pdfSourceByOutputPath = getPdfSourceByOutputPath();
+    const pdfSourceByOutputPath = this.pdfSourceByOutputPath;
     const start = Date.now();
 
     log.debug`Preparing search index background snapshot`;