@abreen/tada 1.4.1 → 1.5.0

package/build/watch.ts

@@ -1,6 +1,4 @@
-#!/usr/bin/env bun
 import fs from 'fs';
-import { fork } from 'child_process';
 import path from 'path';
 import chokidar from 'chokidar';
 import WebSocket, { WebSocketServer } from 'ws';
@@ -31,541 +29,531 @@ import { getProcessedExtensions } from './utils/file-types';
 import { ContentRenderer } from './generate-content-assets';
 import { WatchPagefindRunner } from './pagefind';
 import { ContentChangeDetector } from './content-watch';
+import { startServer } from './serve';
+
+export async function runWatch(options: {
+  httpPort?: number;
+  wsPort?: number;
+}): Promise<void> {
+  const httpPort = options.httpPort ?? null;
+  const WEBSOCKET_PORT = options.wsPort ?? 35729;
+  const DEBOUNCE_MS = 300;
+  const RELOAD_CLIENT_PATH = path.resolve(
+    getPackageDir(),
+    'build/watch-reload-client.ts',
+  );
 
-function getArg(name: string): number | null {
-  const idx = process.argv.indexOf(name);
-  if (idx !== -1 && process.argv[idx + 1]) {
-    const val = parseInt(process.argv[idx + 1], 10);
-    if (val > 0 && val < 65536) {
-      return val;
-    }
+  // Bundle the reload client separately to work around a Bun bundler bug where
+  // side-effect-only JS entrypoints are tree-shaken when bundled alongside SCSS
+  // entrypoints processed by a plugin.
+  async function bundleReloadClient(): Promise<string[]> {
+    const result = await Bun.build({
+      entrypoints: [RELOAD_CLIENT_PATH],
+      outdir: getDistDir(),
+      naming: '[name].bundle.[ext]',
+      sourcemap: 'inline',
+      define: { __WEBSOCKET_PORT__: String(WEBSOCKET_PORT) },
+    });
+    return result.outputs.map(output =>
+      path
+        .relative(getDistDir(), output.path)
+        .split(path.sep)
+        .join(path.posix.sep),
+    );
   }
-  return null;
-}
-
-const httpPort = getArg('--port');
-const WEBSOCKET_PORT = getArg('--ws-port') ?? 35729;
-const DEBOUNCE_MS = 300;
-const RELOAD_CLIENT_PATH = path.resolve(
-  getPackageDir(),
-  'build/watch-reload-client.ts',
-);
-
-// Bundle the reload client separately to work around a Bun bundler bug where
-// side-effect-only JS entrypoints are tree-shaken when bundled alongside SCSS
-// entrypoints processed by a plugin.
-async function bundleReloadClient(): Promise<string[]> {
-  const result = await Bun.build({
-    entrypoints: [RELOAD_CLIENT_PATH],
-    outdir: getDistDir(),
-    naming: '[name].bundle.[ext]',
-    sourcemap: 'inline',
-    define: { __WEBSOCKET_PORT__: String(WEBSOCKET_PORT) },
-  });
-  return result.outputs.map(output =>
-    path
-      .relative(getDistDir(), output.path)
-      .split(path.sep)
-      .join(path.posix.sep),
-  );
-}
 
-type ChangeCategory = 'content' | 'public' | 'config';
+  type ChangeCategory = 'content' | 'public' | 'config';
 
-const log = makeLogger(__filename);
-const wslog = makeLogger('WebSocket');
+  const log = makeLogger(import.meta.url);
+  const wslog = makeLogger('WebSocket');
 
-// --- WebSocket server ---
+  // WebSocket server
 
-let webSocketsReady = false;
-let watcherReady = false;
-let webServerReady = false;
-let webServerTimeout: ReturnType<typeof setTimeout> | undefined;
-let serveStarted = false;
+  let webSocketsReady = false;
+  let watcherReady = false;
+  let webServerReady = false;
+  let webServerTimeout: ReturnType<typeof setTimeout> | undefined;
+  let serveStarted = false;
 
-let wss: WebSocketServer | null = null;
-try {
-  wss = new WebSocketServer({ port: WEBSOCKET_PORT });
+  let wss: WebSocketServer | null = null;
+  try {
+    wss = new WebSocketServer({ port: WEBSOCKET_PORT });
 
-  wss.on('connection', (conn: WebSocket) => {
-    wslog.debug`WebSocket client connected`;
-    if (watcherReady && conn.readyState === WebSocket.OPEN) {
-      if (initialBuildFailed) {
-        conn.send('error');
+    wss.on('connection', (conn: WebSocket) => {
+      wslog.debug`WebSocket client connected`;
+      if (watcherReady && conn.readyState === WebSocket.OPEN) {
+        if (initialBuildFailed) {
+          conn.send('error');
+        }
+        conn.send('ready');
       }
-      conn.send('ready');
-    }
-    conn.on('close', () => {
-      wslog.debug`WebSocket client disconnected`;
+      conn.on('close', () => {
+        wslog.debug`WebSocket client disconnected`;
+      });
     });
-  });
-
-  wss.on('error', (err: Error) => {
-    wslog.error`WebSocket server error: ${err.message}`;
-  });
-
-  wss.on('listening', () => {
-    wslog.debug`WebSocket server listening at ws://localhost:${WEBSOCKET_PORT}`;
-    webSocketsReady = true;
-  });
-} catch (err) {
-  wslog.error`Failed to start WebSocket server on port ${WEBSOCKET_PORT}: ${(err as Error).message}`;
-}
 
-function broadcast(msg: string): void {
-  if (wss == null || !webSocketsReady) {
-    return;
-  }
-  wslog.debug`Broadcasting "${msg}" to WebSocket clients`;
-  wss.clients.forEach((client: WebSocket) => {
-    if (client.readyState === WebSocket.OPEN) {
-      client.send(msg);
-    }
-  });
-}
+    wss.on('error', (err: Error) => {
+      wslog.error`WebSocket server error: ${err.message}`;
+    });
 
-// --- Dev server ---
-
-function serve(): void {
-  const serveArgs = httpPort != null ? ['--port', String(httpPort)] : [];
-  const child = fork(path.join(__dirname, 'serve.js'), serveArgs, {
-    stdio: 'inherit',
-  });
-  child.on('close', (code: number | null) => {
-    webServerReady = false;
-    log.error`Web server exited with code ${code}`;
-    process.exit(2);
-  });
-  child.on('error', (err: Error) => {
-    webServerReady = false;
-    log.error`Web server failed: ${err.message}`;
-  });
-  child.on('message', (msg: Record<string, unknown>) => {
-    if (msg.ready) {
-      webServerReady = true;
-      clearTimeout(webServerTimeout);
-    }
-  });
+    wss.on('listening', () => {
+      wslog.debug`WebSocket server listening at ws://localhost:${WEBSOCKET_PORT}`;
+      webSocketsReady = true;
+    });
+  } catch (err) {
+    wslog.error`Failed to start WebSocket server on port ${WEBSOCKET_PORT}: ${(err as Error).message}`;
+  }
 
-  webServerTimeout = setTimeout(() => {
-    if (webServerReady) {
+  function broadcast(msg: string): void {
+    if (wss == null || !webSocketsReady) {
       return;
     }
-    log.error`Web server failed to report within 10 seconds, exiting`;
-    process.exit(3);
-  }, 10000);
-}
-
-// --- Path helpers ---
-
-function toContentMarkdownPath(filePath: string): string | null {
-  if (!filePath) {
-    return null;
-  }
-  const ext = path.extname(filePath).toLowerCase();
-  if (!['.md', '.markdown'].includes(ext)) {
-    return null;
+    wslog.debug`Broadcasting "${msg}" to WebSocket clients`;
+    wss.clients.forEach((client: WebSocket) => {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(msg);
+      }
+    });
   }
 
-  const normalizedContentDir = path.resolve(contentDir) + path.sep;
-  const normalizedFilePath = path.resolve(filePath);
-  if (!normalizedFilePath.startsWith(normalizedContentDir)) {
-    return null;
-  }
+  // Dev server
 
-  return path
-    .relative(contentDir, normalizedFilePath)
-    .split(path.sep)
-    .join(path.posix.sep);
-}
+  function serve(): void {
+    startServer({
+      port: httpPort ?? undefined,
+      distDir,
+      onReady: _port => {
+        webServerReady = true;
+        clearTimeout(webServerTimeout);
+      },
+    });
 
-function toPublicRelativePath(filePath: string): string | null {
-  if (!filePath) {
-    return null;
-  }
-  const normalizedPublicDir = path.resolve(publicDir) + path.sep;
-  const normalizedFilePath = path.resolve(filePath);
-  if (!normalizedFilePath.startsWith(normalizedPublicDir)) {
-    return null;
+    webServerTimeout = setTimeout(() => {
+      if (webServerReady) {
+        return;
+      }
+      log.error`Web server failed to report within 10 seconds, exiting`;
+      process.exit(3);
+    }, 10000);
   }
-  return path
-    .relative(publicDir, normalizedFilePath)
-    .split(path.sep)
-    .join(path.posix.sep);
-}
 
-// --- Watch mode ---
-
-const contentDir: string = getContentDir();
-const publicDir: string = getPublicDir();
-const distDir: string = getDistDir();
-
-let siteVariables: SiteVariables;
-let processedExtSet = new Set<string>();
-let publicRelPaths: Set<string> = new Set();
-let contentAssetRelPaths: Set<string> = new Set();
-let contentRenderer: ContentRenderer;
-let changeDetector: ContentChangeDetector;
-let pagefindRunner: WatchPagefindRunner | undefined;
-let assetFiles: string[] = [];
-let debounceTimer: ReturnType<typeof setTimeout> | null = null;
-const pendingChanges = new Set<string>();
-let rebuilding = false;
-
-async function initialBuild(): Promise<void> {
-  siteVariables = getDevSiteVariables();
-  processedExtSet = new Set(
-    getProcessedExtensions(Object.keys(siteVariables.codeLanguages || {})),
-  );
-  fs.mkdirSync(distDir, { recursive: true });
+  // Path helpers
+
+  function toContentMarkdownPath(filePath: string): string | null {
+    if (!filePath) {
+      return null;
+    }
+    const ext = path.extname(filePath).toLowerCase();
+    if (!['.md', '.markdown'].includes(ext)) {
+      return null;
+    }
 
-  compileTemplates(siteVariables);
-  contentRenderer = new ContentRenderer(siteVariables);
-  changeDetector = new ContentChangeDetector(siteVariables);
+    const normalizedContentDir = path.resolve(contentDir) + path.sep;
+    const normalizedFilePath = path.resolve(filePath);
+    if (!normalizedFilePath.startsWith(normalizedContentDir)) {
+      return null;
+    }
 
-  if (isFeatureEnabled(siteVariables, 'search')) {
-    pagefindRunner = new WatchPagefindRunner(siteVariables);
+    return path
+      .relative(contentDir, normalizedFilePath)
+      .split(path.sep)
+      .join(path.posix.sep);
   }
 
-  await contentRenderer.initHighlighter();
+  function toPublicRelativePath(filePath: string): string | null {
+    if (!filePath) {
+      return null;
+    }
+    const normalizedPublicDir = path.resolve(publicDir) + path.sep;
+    const normalizedFilePath = path.resolve(filePath);
+    if (!normalizedFilePath.startsWith(normalizedPublicDir)) {
+      return null;
+    }
+    return path
+      .relative(publicDir, normalizedFilePath)
+      .split(path.sep)
+      .join(path.posix.sep);
+  }
 
-  assetFiles = [
-    ...(await bundle(siteVariables, { mode: 'development' })),
-    ...(await bundleReloadClient()),
-  ];
+  // Watch mode
+
+  const contentDir: string = getContentDir();
+  const publicDir: string = getPublicDir();
+  const distDir: string = getDistDir();
+
+  let siteVariables: SiteVariables;
+  let processedExtSet = new Set<string>();
+  let publicRelPaths: Set<string> = new Set();
+  let contentAssetRelPaths: Set<string> = new Set();
+  let contentRenderer: ContentRenderer;
+  let changeDetector: ContentChangeDetector;
+  let pagefindRunner: WatchPagefindRunner | undefined;
+  let assetFiles: string[] = [];
+  let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+  const pendingChanges = new Set<string>();
+  let rebuilding = false;
+
+  async function initialBuild(): Promise<void> {
+    siteVariables = getDevSiteVariables();
+    processedExtSet = new Set(
+      getProcessedExtensions(Object.keys(siteVariables.codeLanguages || {})),
+    );
+    fs.mkdirSync(distDir, { recursive: true });
+
+    compileTemplates(siteVariables);
+    contentRenderer = new ContentRenderer(siteVariables);
+    changeDetector = new ContentChangeDetector(siteVariables);
+
+    if (isFeatureEnabled(siteVariables, 'search')) {
+      pagefindRunner = new WatchPagefindRunner(siteVariables);
+    }
 
-  copyFonts(distDir);
-  copyKatexAssets(distDir);
+    await contentRenderer.initHighlighter();
 
-  if (isFeatureEnabled(siteVariables, 'favicon')) {
-    await generateFavicons(siteVariables, distDir);
-    generateWebAppManifest(siteVariables, distDir);
-  }
+    assetFiles = [
+      ...(await bundle(siteVariables, { mode: 'development' })),
+      ...(await bundleReloadClient()),
+    ];
 
-  publicRelPaths = copyPublicFiles(publicDir, distDir);
-  contentAssetRelPaths = copyContentAssets(
-    contentDir,
-    distDir,
-    [...processedExtSet],
-    publicRelPaths,
-  );
+    copyFonts(distDir);
+    copyKatexAssets(distDir);
 
-  const result = contentRenderer.processContent({ distDir, assetFiles });
+    if (isFeatureEnabled(siteVariables, 'favicon')) {
+      await generateFavicons(siteVariables, distDir);
+      generateWebAppManifest(siteVariables, distDir);
+    }
 
-  for (const err of result.errors) {
-    log.error`${err.message}`;
-  }
+    publicRelPaths = copyPublicFiles(publicDir, distDir);
+    contentAssetRelPaths = copyContentAssets(
+      contentDir,
+      distDir,
+      [...processedExtSet],
+      publicRelPaths,
+    );
 
-  if (result.errors.length === 0) {
-    printFlair();
+    const result = contentRenderer.processContent({ distDir, assetFiles });
 
-    if (pagefindRunner) {
-      pagefindRunner.update(distDir, result.htmlAssetsByPath);
-      setImmediate(() => pagefindRunner!.run());
+    for (const err of result.errors) {
+      log.error`${err.message}`;
     }
 
-    if (!serveStarted) {
-      serveStarted = true;
-      serve();
+    if (result.errors.length === 0) {
+      printFlair();
+
+      if (pagefindRunner) {
+        pagefindRunner.update(distDir, result.htmlAssetsByPath);
+        setImmediate(() => pagefindRunner!.run());
+      }
+
+      if (!serveStarted) {
+        serveStarted = true;
+        serve();
+      }
     }
   }
-}
 
-function classifyChange(filePath: string): ChangeCategory | null {
-  const resolved = path.resolve(filePath);
-  const resolvedContentDir = path.resolve(contentDir) + path.sep;
-  const resolvedPublicDir = path.resolve(publicDir) + path.sep;
-  const jsonDataDir = getJsonDataDir();
-  const siteConfigPath = path.resolve('site.dev.json');
+  function classifyChange(filePath: string): ChangeCategory | null {
+    const resolved = path.resolve(filePath);
+    const resolvedContentDir = path.resolve(contentDir) + path.sep;
+    const resolvedPublicDir = path.resolve(publicDir) + path.sep;
+    const jsonDataDir = getJsonDataDir();
+    const siteConfigPath = path.resolve('site.dev.json');
 
-  if (resolved.startsWith(resolvedContentDir)) {
-    return 'content';
-  }
-  if (resolved.startsWith(resolvedPublicDir)) {
-    return 'public';
-  }
-  if (
-    resolved === siteConfigPath ||
-    JSON_DATA_FILES.some(f => resolved === path.resolve(jsonDataDir, f))
-  ) {
-    return 'config';
+    if (resolved.startsWith(resolvedContentDir)) {
+      return 'content';
+    }
+    if (resolved.startsWith(resolvedPublicDir)) {
+      return 'public';
+    }
+    if (
+      resolved === siteConfigPath ||
+      JSON_DATA_FILES.some(f => resolved === path.resolve(jsonDataDir, f))
+    ) {
+      return 'config';
+    }
+    return null;
   }
-  return null;
-}
 
-async function rebuild(): Promise<void> {
-  if (rebuilding) {
-    return;
-  }
-  rebuilding = true;
+  async function rebuild(): Promise<void> {
+    if (rebuilding) {
+      return;
+    }
+    rebuilding = true;
 
-  const changes = new Set(pendingChanges);
-  pendingChanges.clear();
+    const changes = new Set(pendingChanges);
+    pendingChanges.clear();
 
-  broadcast('rebuilding');
+    broadcast('rebuilding');
 
-  // Classify changes
-  const categories = new Set<ChangeCategory>();
-  for (const filePath of changes) {
-    const category = classifyChange(filePath);
-    if (category) {
-      categories.add(category);
+    // Classify changes
+    const categories = new Set<ChangeCategory>();
+    for (const filePath of changes) {
+      const category = classifyChange(filePath);
+      if (category) {
+        categories.add(category);
+      }
     }
-  }
 
-  let succeeded = false;
+    let succeeded = false;
+
+    try {
+      // Site config changed, full restart
+      if (categories.has('config')) {
+        log.event`Site config changed, restarting`;
+        siteVariables = getDevSiteVariables();
+        processedExtSet = new Set(
+          getProcessedExtensions(
+            Object.keys(siteVariables.codeLanguages || {}),
+          ),
+        );
+        contentRenderer = new ContentRenderer(siteVariables);
+        changeDetector = new ContentChangeDetector(siteVariables);
+        if (isFeatureEnabled(siteVariables, 'search')) {
+          pagefindRunner = new WatchPagefindRunner(siteVariables);
+        }
+        compileTemplates(siteVariables);
+        await contentRenderer.initHighlighter();
 
-  try {
-    // Site config changed, full restart
-    if (categories.has('config')) {
-      log.event`Site config changed, restarting`;
-      siteVariables = getDevSiteVariables();
-      processedExtSet = new Set(
-        getProcessedExtensions(Object.keys(siteVariables.codeLanguages || {})),
-      );
-      contentRenderer = new ContentRenderer(siteVariables);
-      changeDetector = new ContentChangeDetector(siteVariables);
-      if (isFeatureEnabled(siteVariables, 'search')) {
-        pagefindRunner = new WatchPagefindRunner(siteVariables);
-      }
-      compileTemplates(siteVariables);
-      await contentRenderer.initHighlighter();
+        assetFiles = [
+          ...(await bundle(siteVariables, { mode: 'development' })),
+          ...(await bundleReloadClient()),
+        ];
 
-      assetFiles = [
-        ...(await bundle(siteVariables, { mode: 'development' })),
-        ...(await bundleReloadClient()),
-      ];
+        copyFonts(distDir);
+        copyKatexAssets(distDir);
 
-      copyFonts(distDir);
-      copyKatexAssets(distDir);
+        if (isFeatureEnabled(siteVariables, 'favicon')) {
+          await generateFavicons(siteVariables, distDir);
+          generateWebAppManifest(siteVariables, distDir);
+        }
 
-      if (isFeatureEnabled(siteVariables, 'favicon')) {
-        await generateFavicons(siteVariables, distDir);
-        generateWebAppManifest(siteVariables, distDir);
+        const result = contentRenderer.processContent({ distDir, assetFiles });
+        for (const err of result.errors) {
+          log.error`${err.message}`;
+        }
+        if (result.errors.length === 0) {
+          printFlair();
+          if (!serveStarted) {
+            serveStarted = true;
+            serve();
+          }
+          broadcast('reload');
+          if (pagefindRunner) {
+            pagefindRunner.update(distDir, result.htmlAssetsByPath);
+            setImmediate(() => pagefindRunner!.run());
+          }
+          succeeded = true;
+        }
+        return;
       }
 
-      const result = contentRenderer.processContent({ distDir, assetFiles });
-      for (const err of result.errors) {
-        log.error`${err.message}`;
-      }
-      if (result.errors.length === 0) {
-        printFlair();
-        if (!serveStarted) {
-          serveStarted = true;
-          serve();
+      // Public file changed, copy just that file
+      if (categories.has('public') && !categories.has('content')) {
+        for (const filePath of changes) {
+          if (classifyChange(filePath) === 'public') {
+            const absPath = path.resolve(filePath);
+            if (fs.existsSync(absPath)) {
+              copyPublicFile(publicDir, distDir, absPath, contentAssetRelPaths);
+              const rel = path
+                .relative(publicDir, absPath)
+                .split(path.sep)
+                .join(path.posix.sep);
+              publicRelPaths.add(rel);
+            }
+          }
         }
+        printFlair();
         broadcast('reload');
-        if (pagefindRunner) {
-          pagefindRunner.update(distDir, result.htmlAssetsByPath);
-          setImmediate(() => pagefindRunner!.run());
-        }
         succeeded = true;
+        return;
+      }
+
+      // Content changed, incremental rebuild
+      const detection = changeDetector.detectChanges(changes);
+
+      if (detection.needsRestart) {
+        log.event`Content structure changed, full rebuild`;
+        contentRenderer = new ContentRenderer(siteVariables);
+        await contentRenderer.initHighlighter();
       }
-      return;
-    }
 
-    // Public file changed, copy just that file
-    if (categories.has('public') && !categories.has('content')) {
+      // Log changed content files
       for (const filePath of changes) {
-        if (classifyChange(filePath) === 'public') {
-          const absPath = path.resolve(filePath);
-          if (fs.existsSync(absPath)) {
-            copyPublicFile(publicDir, distDir, absPath, contentAssetRelPaths);
-            const rel = path
-              .relative(publicDir, absPath)
-              .split(path.sep)
-              .join(path.posix.sep);
-            publicRelPaths.add(rel);
+        const markdownPath = toContentMarkdownPath(filePath);
+        if (markdownPath) {
+          log.event`${B`${markdownPath}`} changed, rebuilding`;
+        } else {
+          const pubPath = toPublicRelativePath(filePath);
+          if (pubPath) {
+            log.event`${B`public/${pubPath}`} changed`;
           }
         }
       }
-      printFlair();
-      broadcast('reload');
-      succeeded = true;
-      return;
-    }
-
-    // Content changed, incremental rebuild
-    const detection = changeDetector.detectChanges(changes);
-
-    if (detection.needsRestart) {
-      log.event`Content structure changed, full rebuild`;
-      contentRenderer = new ContentRenderer(siteVariables);
-      await contentRenderer.initHighlighter();
-    }
 
-    // Log changed content files
-    for (const filePath of changes) {
-      const markdownPath = toContentMarkdownPath(filePath);
-      if (markdownPath) {
-        log.event`${B`${markdownPath}`} changed, rebuilding`;
-      } else {
-        const pubPath = toPublicRelativePath(filePath);
-        if (pubPath) {
-          log.event`${B`public/${pubPath}`} changed`;
+      // Copy any changed public files too
+      if (categories.has('public')) {
+        for (const filePath of changes) {
+          if (classifyChange(filePath) === 'public') {
+            const absPath = path.resolve(filePath);
+            if (fs.existsSync(absPath)) {
+              copyPublicFile(publicDir, distDir, absPath, contentAssetRelPaths);
+              const rel = path
+                .relative(publicDir, absPath)
+                .split(path.sep)
+                .join(path.posix.sep);
+              publicRelPaths.add(rel);
+            }
+          }
         }
       }
-    }
 
-    // Copy any changed public files too
-    if (categories.has('public')) {
-      for (const filePath of changes) {
-        if (classifyChange(filePath) === 'public') {
+      // Copy any changed non-processed content files (images, PDFs, etc.)
+      if (categories.has('content')) {
+        for (const filePath of changes) {
+          if (classifyChange(filePath) !== 'content') {
+            continue;
+          }
           const absPath = path.resolve(filePath);
-          if (fs.existsSync(absPath)) {
-            copyPublicFile(publicDir, distDir, absPath, contentAssetRelPaths);
+          const ext = path.extname(absPath).slice(1).toLowerCase();
+          if (!processedExtSet.has(ext) && fs.existsSync(absPath)) {
+            copyContentFile(contentDir, distDir, absPath, publicRelPaths);
             const rel = path
-              .relative(publicDir, absPath)
+              .relative(contentDir, absPath)
               .split(path.sep)
               .join(path.posix.sep);
-            publicRelPaths.add(rel);
+            contentAssetRelPaths.add(rel);
           }
         }
       }
-    }
 
-    // Copy any changed non-processed content files (images, PDFs, etc.)
-    if (categories.has('content')) {
-      for (const filePath of changes) {
-        if (classifyChange(filePath) !== 'content') {
-          continue;
-        }
-        const absPath = path.resolve(filePath);
-        const ext = path.extname(absPath).slice(1).toLowerCase();
-        if (!processedExtSet.has(ext) && fs.existsSync(absPath)) {
-          copyContentFile(contentDir, distDir, absPath, publicRelPaths);
-          const rel = path
-            .relative(contentDir, absPath)
-            .split(path.sep)
-            .join(path.posix.sep);
-          contentAssetRelPaths.add(rel);
-        }
-      }
-    }
+      const watchState: WatchState | undefined = detection.needsRestart
+        ? undefined
+        : {
+            changedContentFiles: detection.changedContentFiles,
+            jsonDataChanged: detection.jsonDataChanged,
+            partialsChanged: detection.partialsChanged,
+          };
 
-    const watchState: WatchState | undefined = detection.needsRestart
-      ? undefined
-      : {
-          changedContentFiles: detection.changedContentFiles,
-          templatesChanged: detection.templatesChanged,
-        };
+      const result = contentRenderer.processContent({
+        distDir,
+        assetFiles,
+        watchState,
+      });
 
-    const result = contentRenderer.processContent({
-      distDir,
-      assetFiles,
-      watchState,
-    });
+      for (const err of result.errors) {
+        log.error`${err.message}`;
+      }
 
-    for (const err of result.errors) {
-      log.error`${err.message}`;
-    }
+      if (result.errors.length === 0) {
+        printFlair();
+        if (!serveStarted) {
+          serveStarted = true;
+          serve();
+        }
+        broadcast('reload');
 
-    if (result.errors.length === 0) {
-      printFlair();
-      if (!serveStarted) {
-        serveStarted = true;
-        serve();
+        if (pagefindRunner) {
+          pagefindRunner.update(distDir, result.htmlAssetsByPath);
+          setImmediate(() => pagefindRunner!.run());
+        }
+        succeeded = true;
+      }
+    } catch (err) {
+      log.error`Build failed: ${(err as Error).message}`;
+    } finally {
+      if (!succeeded) {
+        broadcast('error');
       }
-      broadcast('reload');
+      rebuilding = false;
 
-      if (pagefindRunner) {
-        pagefindRunner.update(distDir, result.htmlAssetsByPath);
-        setImmediate(() => pagefindRunner!.run());
+      // If more changes accumulated during rebuild, schedule another
+      if (pendingChanges.size > 0) {
+        scheduleRebuild();
       }
-      succeeded = true;
-    }
-  } catch (err) {
-    log.error`Build failed: ${(err as Error).message}`;
-  } finally {
-    if (!succeeded) {
-      broadcast('error');
     }
-    rebuilding = false;
+  }
 
-    // If more changes accumulated during rebuild, schedule another
-    if (pendingChanges.size > 0) {
-      scheduleRebuild();
+  function scheduleRebuild(): void {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
     }
+    debounceTimer = setTimeout(rebuild, DEBOUNCE_MS);
   }
-}
 
-function scheduleRebuild(): void {
-  if (debounceTimer) {
-    clearTimeout(debounceTimer);
+  function onFileChange(filePath: string): void {
+    pendingChanges.add(filePath);
+    scheduleRebuild();
   }
-  debounceTimer = setTimeout(rebuild, DEBOUNCE_MS);
-}
-
-function onFileChange(filePath: string): void {
-  pendingChanges.add(filePath);
-  scheduleRebuild();
-}
-
-// --- Start ---
 
-let initialBuildFailed = false;
-
-initialBuild()
-  .catch(err => {
-    log.error`Initial build failed: ${(err as Error).message}`;
-    initialBuildFailed = true;
-  })
-  .finally(() => {
-    const watchPaths: string[] = [contentDir, publicDir];
-
-    // Watch config files (nav.json, authors.json, site config) via the
-    // project root directory (depth 0). Chokidar v4 doesn't emit unlink
-    // for individually watched files, so we must watch the directory.
-    const jsonDataDir = getJsonDataDir();
-    const configFilePaths = new Set([
-      ...JSON_DATA_FILES.map(f => path.resolve(jsonDataDir, f)),
-      path.resolve('site.dev.json'),
-    ]);
-    const configWatcher = chokidar.watch(jsonDataDir, {
-      ignoreInitial: true,
-      depth: 0,
-      awaitWriteFinish: { stabilityThreshold: 100 },
-    });
-    const onConfigFileChange = (filePath: string) => {
-      if (configFilePaths.has(path.resolve(filePath))) {
-        onFileChange(filePath);
+  // Start
+
+  let initialBuildFailed = false;
+
+  initialBuild()
+    .catch(err => {
+      log.error`Initial build failed: ${(err as Error).message}`;
+      initialBuildFailed = true;
+    })
+    .finally(() => {
+      const watchPaths: string[] = [contentDir, publicDir];
+
+      // Watch config files (nav.json, authors.json, site config) via the
+      // project root directory (depth 0). Chokidar v4 doesn't emit unlink
+      // for individually watched files, so we must watch the directory.
+      const jsonDataDir = getJsonDataDir();
+      const configFilePaths = new Set([
+        ...JSON_DATA_FILES.map(f => path.resolve(jsonDataDir, f)),
+        path.resolve('site.dev.json'),
+      ]);
+      const configWatcher = chokidar.watch(jsonDataDir, {
+        ignoreInitial: true,
+        depth: 0,
+        awaitWriteFinish: { stabilityThreshold: 100 },
+      });
+      const onConfigFileChange = (filePath: string) => {
+        if (configFilePaths.has(path.resolve(filePath))) {
+          onFileChange(filePath);
+        }
+      };
+      configWatcher.on('add', onConfigFileChange);
+      configWatcher.on('change', onConfigFileChange);
+      configWatcher.on('unlink', onConfigFileChange);
+
+      const watcher = chokidar.watch(watchPaths, {
+        ignoreInitial: true,
+        awaitWriteFinish: { stabilityThreshold: 100 },
+      });
+
+      watcher.on('change', onFileChange);
+      watcher.on('add', onFileChange);
+      watcher.on('unlink', onFileChange);
+
+      let configWatcherReady = false;
+      let contentWatcherReady = false;
+
+      function onWatcherReady(): void {
+        if (!configWatcherReady || !contentWatcherReady) {
+          return;
+        }
+        watcherReady = true;
+        if (initialBuildFailed) {
+          broadcast('error');
+        }
+        broadcast('ready');
+        log.info`Watching for changes...`;
       }
-    };
-    configWatcher.on('add', onConfigFileChange);
-    configWatcher.on('change', onConfigFileChange);
-    configWatcher.on('unlink', onConfigFileChange);
-
-    const watcher = chokidar.watch(watchPaths, {
-      ignoreInitial: true,
-      awaitWriteFinish: { stabilityThreshold: 100 },
-    });
-
-    watcher.on('change', onFileChange);
-    watcher.on('add', onFileChange);
-    watcher.on('unlink', onFileChange);
 
-    let configWatcherReady = false;
-    let contentWatcherReady = false;
+      configWatcher.on('ready', () => {
+        configWatcherReady = true;
+        onWatcherReady();
+      });
 
-    function onWatcherReady(): void {
-      if (!configWatcherReady || !contentWatcherReady) {
-        return;
-      }
-      watcherReady = true;
-      if (initialBuildFailed) {
-        broadcast('error');
-      }
-      broadcast('ready');
-      log.info`Watching for changes...`;
-    }
-
-    configWatcher.on('ready', () => {
-      configWatcherReady = true;
-      onWatcherReady();
+      watcher.on('ready', () => {
+        contentWatcherReady = true;
+        onWatcherReady();
+      });
     });
 
-    watcher.on('ready', () => {
-      contentWatcherReady = true;
-      onWatcherReady();
-    });
-  });
+  // Return a promise that never resolves (watch mode runs until killed)
+  return new Promise(() => {});
+}