vite-plugin-html-pages 2.0.7 → 2.0.8

package/dist/index.js

@@ -9,6 +9,74 @@ import pLimit from "p-limit";
 import fs from "fs/promises";
 import path2 from "path";
 
+// src/page-helper-generator.ts
+function paramsTypeFromDefinitions(paramDefinitions) {
+  if (paramDefinitions.length === 0) {
+    return "{}";
+  }
+  const fields = paramDefinitions.map((param) => {
+    if (param.type === "single") {
+      return `${JSON.stringify(param.name)}: string`;
+    }
+    if (param.type === "catch-all") {
+      return `${JSON.stringify(param.name)}: string[]`;
+    }
+    return `${JSON.stringify(param.name)}?: string[]`;
+  });
+  return `{ ${fields.join("; ")} }`;
+}
+function generateTypedPageHelper(page) {
+  const paramsType = page ? paramsTypeFromDefinitions(page.paramDefinitions ?? []) : "{}";
+  return `
+export type PageParams = ${paramsType};
+
+export type StaticParams = PageParams[];
+
+export type DataContext = {
+  params: PageParams;
+  dev: boolean;
+};
+
+export type RenderContext<TData = unknown> = {
+  params: PageParams;
+  data: TData;
+  dev: boolean;
+};
+
+export type PageContext<TData = unknown> = {
+  params: PageParams;
+  data?: TData;
+  dev: boolean;
+};
+
+export type PageModule<TData = unknown> = {
+  generateStaticParams?: () => StaticParams | Promise<StaticParams>;
+  data?: (ctx: DataContext) => TData | Promise<TData>;
+  render: (ctx: RenderContext<TData>) => any;
+};
+
+export function definePage<T extends (ctx: PageContext) => any>(fn: T): T {
+  return fn;
+}
+
+export function defineData<T extends (ctx: DataContext) => any>(fn: T): T {
+  return fn;
+}
+
+export function defineStaticParams<
+  T extends () => StaticParams | Promise<StaticParams>
+>(fn: T): T {
+  return fn;
+}
+
+export function definePageModule<TData>(
+  mod: PageModule<TData>,
+): PageModule<TData> {
+  return mod;
+}
+`;
+}
+
 // src/path-utils.ts
 import path from "path";
 function toPosix(value) {
@@ -31,68 +99,53 @@ function stripPageSuffix(filePath, extensions) {
 }
 
 // src/typegen.ts
-function paramsTypeFromDefinitions(paramDefinitions) {
-  if (paramDefinitions.length === 0) {
-    return "{}";
-  }
-  const fields = paramDefinitions.map((param) => {
-    if (param.type === "single") {
-      return `${param.name}: string`;
-    }
-    if (param.type === "catch-all") {
-      return `${param.name}: string[]`;
-    }
-    return `${param.name}?: string[]`;
-  });
-  return `{ ${fields.join("; ")} }`;
-}
 function pageHelperModuleSource(page) {
   const paramsType = paramsTypeFromDefinitions(page.paramDefinitions ?? []);
   return `export type PageParams = ${paramsType};
-  
-  export type StaticParams = PageParams[];
-  
-  export type DataContext = {
-    params: PageParams;
-    dev: boolean;
-  };
-  
-  export type RenderContext<TData = unknown> = {
-    params: PageParams;
-    data: TData;
-    dev: boolean;
-  };
-  
-  export type PageContext<TData = unknown> = {
-    params: PageParams;
-    data?: TData;
-    dev: boolean;
-  };
-  
-  export type RenderResult = unknown;
-  
-  export type PageModule<TData = unknown> = {
-    generateStaticParams?: () => StaticParams | Promise<StaticParams>;
-    data?: (ctx: DataContext) => TData | Promise<TData>;
-    render: (ctx: RenderContext<TData>) => RenderResult | Promise<RenderResult>;
-  };
-  
-  export declare function definePage<
-    T extends (ctx: PageContext) => RenderResult | Promise<RenderResult>
-  >(fn: T): T;
-  
-  export declare function defineData<
-    T extends (ctx: DataContext) => unknown | Promise<unknown>
-  >(fn: T): T;
-  
-  export declare function defineStaticParams<
-    T extends () => StaticParams | Promise<StaticParams>
-  >(fn: T): T;
-  
-  export declare function definePageModule<TData>(
-    mod: PageModule<TData>
-  ): PageModule<TData>;
-  `;
+
+export type StaticParams = PageParams[];
+
+export type DataContext = {
+  params: PageParams;
+  dev: boolean;
+};
+
+export type RenderContext<TData = unknown> = {
+  params: PageParams;
+  data: TData;
+  dev: boolean;
+};
+
+export type PageContext<TData = unknown> = {
+  params: PageParams;
+  data?: TData;
+  dev: boolean;
+};
+
+export type RenderResult = unknown;
+
+export type PageModule<TData = unknown> = {
+  generateStaticParams?: () => StaticParams | Promise<StaticParams>;
+  data?: (ctx: DataContext) => TData | Promise<TData>;
+  render: (ctx: RenderContext<TData>) => RenderResult | Promise<RenderResult>;
+};
+
+export declare function definePage<
+  T extends (ctx: PageContext) => RenderResult | Promise<RenderResult>
+>(fn: T): T;
+
+export declare function defineData<
+  T extends (ctx: DataContext) => unknown | Promise<unknown>
+>(fn: T): T;
+
+export declare function defineStaticParams<
+  T extends () => StaticParams | Promise<StaticParams>
+>(fn: T): T;
+
+export declare function definePageModule<TData>(
+  mod: PageModule<TData>
+): PageModule<TData>;
+`;
 }
 function stripPageExtension(filePath) {
   return filePath.replace(/\.(ht|html)\.(js|ts|jsx|tsx)$/i, "");
@@ -354,8 +407,17 @@ var PLUGIN_NAME = "vite-plugin-html-pages";
 var VIRTUAL_BUILD_ENTRY_ID = `\0${PLUGIN_NAME}:build-entry`;
 var VIRTUAL_PAGE_HELPER_ID = `${PLUGIN_NAME}/page`;
 var RESOLVED_VIRTUAL_PAGE_HELPER_PREFIX = `\0${PLUGIN_NAME}/page:`;
-var VIRTUAL_MANIFEST_ID = `\0virtual:${PLUGIN_NAME}-manifest`;
 var CACHE_DIR_NAME = `node_modules/.cache/${PLUGIN_NAME}`;
+var DEFAULT_PAGE_EXTENSIONS = [
+  ".ht.js",
+  ".html.js",
+  ".ht.ts",
+  ".html.ts",
+  ".ht.jsx",
+  ".html.jsx",
+  ".ht.tsx",
+  ".html.tsx"
+];
 var VIRTUAL_JSX_RUNTIME_ID = `${PLUGIN_NAME}/jsx-runtime`;
 var VIRTUAL_JSX_DEV_RUNTIME_ID = `${PLUGIN_NAME}/jsx-dev-runtime`;
 var RESOLVED_VIRTUAL_JSX_RUNTIME_ID = `\0${VIRTUAL_JSX_RUNTIME_ID}`;
@@ -515,7 +577,7 @@ async function discoverEntryPages(root, options) {
   const fgModule = await import("fast-glob");
   const fg2 = fgModule.default ?? fgModule;
   const pagesDir = options.pagesDir ?? "src";
-  const pageExtensions = options.pageExtensions?.length ? options.pageExtensions : [".ht.js", ".html.js", ".ht.ts", ".html.ts", ".ht.jsx", ".html.jsx", ".ht.tsx", ".html.tsx"];
+  const pageExtensions = options.pageExtensions?.length ? options.pageExtensions : DEFAULT_PAGE_EXTENSIONS;
   const include = Array.isArray(options.include) ? options.include : options.include ? [options.include] : buildDefaultIncludeGlobs(pagesDir, pageExtensions);
   const exclude = Array.isArray(options.exclude) ? options.exclude : options.exclude ? [options.exclude] : [];
   const pagesRoot = normalizeFsPath(path4.join(root, pagesDir));
@@ -700,6 +762,9 @@ async function renderPage(page, mod, dev = false) {
       ctx.data = await mod.data(ctx);
     }
     const result = await resolveRenderResult(page, mod, ctx);
+    if (result == null) {
+      throw invalidHtmlReturn(page, result);
+    }
     if (typeof result === "string") {
       return ensureDoctype(result);
     }
@@ -727,79 +792,9 @@ async function renderPage(page, mod, dev = false) {
 import path5 from "path";
 import {
   createServer,
-  isRunnableDevEnvironment
+  isRunnableDevEnvironment,
+  loadConfigFromFile
 } from "vite";
-
-// src/page-helper-generator.ts
-function paramsTypeFromDefinitions2(paramDefinitions) {
-  if (paramDefinitions.length === 0) {
-    return "{}";
-  }
-  const fields = paramDefinitions.map((param) => {
-    if (param.type === "single") {
-      return `${JSON.stringify(param.name)}: string`;
-    }
-    if (param.type === "catch-all") {
-      return `${JSON.stringify(param.name)}: string[]`;
-    }
-    return `${JSON.stringify(param.name)}?: string[]`;
-  });
-  return `{ ${fields.join("; ")} }`;
-}
-function generateTypedPageHelper(page) {
-  const paramsType = page ? paramsTypeFromDefinitions2(page.paramDefinitions ?? []) : "{}";
-  return `
-export type PageParams = ${paramsType};
-
-export type StaticParams = PageParams[];
-
-export type DataContext = {
-  params: PageParams;
-  dev: boolean;
-};
-
-export type RenderContext<TData = unknown> = {
-  params: PageParams;
-  data: TData;
-  dev: boolean;
-};
-
-export type PageContext<TData = unknown> = {
-  params: PageParams;
-  data?: TData;
-  dev: boolean;
-};
-
-export type PageModule<TData = unknown> = {
-  generateStaticParams?: () => StaticParams | Promise<StaticParams>;
-  data?: (ctx: DataContext) => TData | Promise<TData>;
-  render: (ctx: RenderContext<TData>) => any;
-};
-
-export function definePage<T extends (ctx: PageContext) => any>(fn: T): T {
-  return fn;
-}
-
-export function defineData<T extends (ctx: DataContext) => any>(fn: T): T {
-  return fn;
-}
-
-export function defineStaticParams<
-  T extends () => StaticParams | Promise<StaticParams>
->(fn: T): T {
-  return fn;
-}
-
-export function definePageModule<TData>(
-  mod: PageModule<TData>,
-): PageModule<TData> {
-  return mod;
-}
-`;
-}
-
-// src/module-loader.ts
-var buildServer = null;
 async function importPageModule(server, url) {
   const environment = server.environments.ssr;
   if (!isRunnableDevEnvironment(environment)) {
@@ -810,15 +805,12 @@ async function importPageModule(server, url) {
   const mod = await environment.runner.import(url);
   return normalizeLoadedPageModule(mod);
 }
-function isStructuredPageModule2(value) {
-  return !!value && typeof value === "object" && "render" in value && typeof value.render === "function";
-}
 function isLocalPageTypesImport(id) {
   return /^\.\/\$types(?:\.[A-Za-z0-9_.-]+)?$/.test(id);
 }
 function normalizeLoadedPageModule(mod) {
   const pageModule = mod ?? {};
-  if (isStructuredPageModule2(pageModule.default)) {
+  if (isStructuredPageModule(pageModule.default)) {
     const structured = pageModule.default;
     return {
       default: structured.render,
@@ -830,83 +822,125 @@ function normalizeLoadedPageModule(mod) {
   }
   return pageModule;
 }
+async function flattenPluginOptions(option) {
+  const resolved = await option;
+  if (!resolved) return [];
+  if (Array.isArray(resolved)) {
+    const nested = await Promise.all(
+      resolved.map((entry) => flattenPluginOptions(entry))
+    );
+    return nested.flat();
+  }
+  return [resolved];
+}
+async function loadUserConfig(args) {
+  if (!args.configFile) {
+    return { userConfig: {}, userPlugins: [] };
+  }
+  const loaded = await loadConfigFromFile(
+    { command: "serve", mode: args.mode },
+    args.configFile,
+    args.root
+  );
+  if (!loaded) {
+    return { userConfig: {}, userPlugins: [] };
+  }
+  const plugins = await flattenPluginOptions(loaded.config.plugins);
+  return {
+    userConfig: loaded.config,
+    // Filter ourselves out so evaluating page modules does not
+    // recursively spawn more build loaders.
+    userPlugins: plugins.filter((plugin) => plugin.name !== PLUGIN_NAME)
+  };
+}
+function createPageHelperPlugin(getPages) {
+  return {
+    name: `${PLUGIN_NAME}:page-helper`,
+    resolveId(id, importer) {
+      if (id === VIRTUAL_PAGE_HELPER_ID && importer) {
+        return `${RESOLVED_VIRTUAL_PAGE_HELPER_PREFIX}${importer}`;
+      }
+      if (importer && isLocalPageTypesImport(id)) {
+        return `${VIRTUAL_LOCAL_TYPES_PREFIX}${importer}::${id}`;
+      }
+      return null;
+    },
+    async load(id) {
+      if (id.startsWith(VIRTUAL_LOCAL_TYPES_PREFIX)) {
+        return `
+export {
+  definePage,
+  defineData,
+  defineStaticParams,
+  definePageModule
+} from 'vite-plugin-html-pages/page';
+`;
+      }
+      if (!id.startsWith(RESOLVED_VIRTUAL_PAGE_HELPER_PREFIX)) {
+        return null;
+      }
+      const importer = id.slice(RESOLVED_VIRTUAL_PAGE_HELPER_PREFIX.length);
+      const pages = await getPages();
+      const normalizedImporter = path5.resolve(importer);
+      const page = pages.find(
+        (candidate) => path5.resolve(candidate.absolutePath) === normalizedImporter
+      );
+      return generateTypedPageHelper(page);
+    }
+  };
+}
 async function createPageModuleLoader(args) {
   const { mode, root, server, getPages } = args;
   if (mode === "dev") {
     if (!server) {
       throw new Error("[vite-plugin-html-pages] dev server not available");
     }
-    return async (_entryPath, relativePath) => importPageModule(server, `/${relativePath}`);
+    return {
+      loadModule: async (_entryPath, relativePath) => importPageModule(server, `/${relativePath}`),
+      close: async () => {
+      }
+    };
   }
   if (!getPages) {
     throw new Error(
       "[vite-plugin-html-pages] getPages is required in build mode"
     );
   }
-  if (!buildServer) {
-    const config = {
-      root,
-      configFile: false,
-      logLevel: "error",
-      appType: "custom",
-      esbuild: {
-        jsx: "automatic",
-        jsxImportSource: "vite-plugin-html-pages"
-      },
-      server: {
-        middlewareMode: true
-      },
-      plugins: [
-        {
-          name: "vite-plugin-html-pages:page-helper",
-          resolveId(id, importer) {
-            if (id === VIRTUAL_PAGE_HELPER_ID && importer) {
-              return `${RESOLVED_VIRTUAL_PAGE_HELPER_PREFIX}${importer}`;
-            }
-            if (importer && isLocalPageTypesImport(id)) {
-              return `${VIRTUAL_LOCAL_TYPES_PREFIX}${importer}::${id}`;
-            }
-            return null;
-          },
-          async load(id) {
-            if (id.startsWith(VIRTUAL_LOCAL_TYPES_PREFIX)) {
-              return `
-export {
-  definePage,
-  defineData,
-  defineStaticParams,
-  definePageModule
-} from 'vite-plugin-html-pages/page';
-`;
-            }
-            if (!id.startsWith(RESOLVED_VIRTUAL_PAGE_HELPER_PREFIX)) {
-              return null;
-            }
-            const importer = id.slice(
-              RESOLVED_VIRTUAL_PAGE_HELPER_PREFIX.length
-            );
-            const pages = await getPages();
-            const normalizedImporter = path5.resolve(importer);
-            const page = pages.find(
-              (candidate) => path5.resolve(candidate.absolutePath) === normalizedImporter
-            );
-            return generateTypedPageHelper(page);
-          }
-        }
-      ]
-    };
-    buildServer = await createServer(config);
-  }
-  return async (entryPath) => {
-    const relativePath = "/" + path5.relative(root, entryPath).replace(/\\/g, "/");
-    return importPageModule(buildServer, relativePath);
+  const configMode = args.configMode ?? "production";
+  const { userConfig, userPlugins } = await loadUserConfig({
+    root,
+    configFile: args.configFile,
+    mode: configMode
+  });
+  const config = {
+    ...userConfig,
+    root,
+    mode: configMode,
+    configFile: false,
+    logLevel: "error",
+    appType: "custom",
+    esbuild: userConfig.esbuild === false ? false : {
+      ...userConfig.esbuild,
+      jsx: "automatic",
+      jsxImportSource: PLUGIN_NAME
+    },
+    server: {
+      ...userConfig.server,
+      middlewareMode: true,
+      watch: null
+    },
+    plugins: [...userPlugins, createPageHelperPlugin(getPages)]
+  };
+  const buildServer = await createServer(config);
+  return {
+    loadModule: async (entryPath) => {
+      const relativePath = "/" + path5.relative(root, entryPath).replace(/\\/g, "/");
+      return importPageModule(buildServer, relativePath);
+    },
+    close: async () => {
+      await buildServer.close();
+    }
   };
-}
-async function closePageModuleLoader() {
-  if (buildServer) {
-    await buildServer.close();
-    buildServer = null;
-  }
 }
 
 // src/dev-server.ts
@@ -925,8 +959,12 @@ function normalizeRoutePath2(input) {
 function shouldSkipHtmlRouting(url, pagesDir) {
   return url.startsWith("/@vite") || url.startsWith("/@fs/") || url.startsWith("/node_modules/") || url.startsWith(`/${pagesDir}/`) || url === "/favicon.ico" || isStaticAssetRequest(url);
 }
+function hasDotDotSegment(url) {
+  return url.split("/").includes("..");
+}
 function tryRewriteRootAssetToSrc(root, pagesDir, url) {
   if (!url.startsWith("/")) return null;
+  if (hasDotDotSegment(url)) return null;
   if (!isStaticAssetRequest(url)) return null;
   if (url.startsWith(`/${pagesDir}/`)) return null;
   const candidate = path6.join(root, pagesDir, url.slice(1));
@@ -939,6 +977,7 @@ function rewriteRootAssetUrlsInDevHtml(html, root, pagesDir) {
   return html.replace(
     /\b(href|src)=["'](\/[^"']+)["']/g,
     (full, attr, url) => {
+      if (hasDotDotSegment(url)) return full;
       if (!isStaticAssetRequest(url)) return full;
       if (url.startsWith(`/${pagesDir}/`)) return full;
       const candidate = path6.join(root, pagesDir, url.slice(1));
@@ -949,7 +988,7 @@ function rewriteRootAssetUrlsInDevHtml(html, root, pagesDir) {
 }
 function installDevServer(args) {
   const { server, root, pagesDir, getPages } = args;
-  const loadModulePromise = createPageModuleLoader({
+  const loaderPromise = createPageModuleLoader({
     mode: "dev",
     root,
     server
@@ -960,7 +999,9 @@ function installDevServer(args) {
       const url = normalizeRoutePath2(originalUrl);
       const rewrittenAssetUrl = tryRewriteRootAssetToSrc(root, pagesDir, url);
       if (rewrittenAssetUrl) {
-        req.url = rewrittenAssetUrl + originalUrl.slice(url.length);
+        const suffixIndex = originalUrl.search(/[?#]/);
+        const suffix = suffixIndex === -1 ? "" : originalUrl.slice(suffixIndex);
+        req.url = rewrittenAssetUrl + suffix;
         return next();
       }
       if (shouldSkipHtmlRouting(url, pagesDir)) {
@@ -973,7 +1014,7 @@ function installDevServer(args) {
       if (!page) {
         return next();
       }
-      const loadModule = await loadModulePromise;
+      const { loadModule } = await loaderPromise;
       const mod = await loadModule(page.entryPath, page.relativePath);
       if (!mod) {
         return next();
@@ -1029,10 +1070,11 @@ function collectScriptSrcs(html) {
 }
 function collectStylesheetHrefs(html) {
   const out = [];
-  for (const match of html.matchAll(
-    /<link\b[^>]*\brel=["']stylesheet["'][^>]*\bhref=["']([^"']+)["'][^>]*>/gi
-  )) {
-    out.push(match[1]);
+  for (const match of html.matchAll(/<link\b[^>]*>/gi)) {
+    const tag = match[0];
+    if (!/\brel=["']?stylesheet["']?/i.test(tag)) continue;
+    const href = tag.match(/\bhref=["']([^"']+)["']/i);
+    if (href) out.push(href[1]);
   }
   return out;
 }
@@ -1048,6 +1090,20 @@ function collectLiteralDynamicImports(html) {
 function unique(values) {
   return [...new Set(values)];
 }
+function collectHrefSrcUrls(html) {
+  const out = [];
+  for (const match of html.matchAll(/\b(?:href|src)=["']([^"']+)["']/gi)) {
+    out.push(match[1]);
+  }
+  return out;
+}
+function collectLocalAssetUrls(html) {
+  const candidates = [
+    ...collectHrefSrcUrls(html),
+    ...collectLiteralDynamicImports(html)
+  ];
+  return unique(candidates.filter(isLocalRootUrl).map(stripQueryAndHash));
+}
 function formatPageLabel(pageLabel) {
   return pageLabel ? ` (${pageLabel})` : "";
 }
@@ -1132,6 +1188,12 @@ async function buildPageIndex(args) {
     const mod = modulesByEntry.get(entry.entryPath) ?? {};
     if (entry.dynamic) {
       const rows = (mod.generateStaticParams ? await mod.generateStaticParams() : []) ?? [];
+      const paramRows = Array.isArray(rows) ? rows : [];
+      if (paramRows.length === 0) {
+        console.warn(
+          `[${PLUGIN_NAME}] \u26A0\uFE0F Dynamic page "${entry.relativePath}" generated no routes. Export generateStaticParams() returning at least one params object to emit pages for it.`
+        );
+      }
       pages.push(
         ...expandStaticPaths(
           {
@@ -1144,7 +1206,7 @@ async function buildPageIndex(args) {
             paramNames: entry.paramNames,
             paramDefinitions: entry.paramDefinitions
           },
-          Array.isArray(rows) ? rows : [],
+          paramRows,
           cleanUrls
         )
       );
@@ -1328,8 +1390,8 @@ function warnIfNotESM(root) {
   } catch {
   }
 }
-function isLocalPageTypesImport2(id) {
-  return /^\.\/\$types(?:\.[A-Za-z0-9_.-]+)?$/.test(id);
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 function chunkArray(items, size) {
   const out = [];
@@ -1338,6 +1400,50 @@ function chunkArray(items, size) {
   }
   return out;
 }
+var DEFAULT_404_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>404 - Page Not Found</title>
+    <style>
+      :root {
+        color-scheme: light dark;
+      }
+      body {
+        margin: 0;
+        font-family: system-ui, sans-serif;
+        min-height: 100vh;
+        display: grid;
+        place-items: center;
+        padding: 2rem;
+      }
+      main {
+        max-width: 40rem;
+        text-align: center;
+      }
+      h1 {
+        font-size: 3rem;
+        margin: 0 0 1rem;
+      }
+      p {
+        margin: 0.5rem 0;
+        line-height: 1.5;
+      }
+      a {
+        color: inherit;
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>404</h1>
+      <p>Page not found.</p>
+      <p><a href="/">Go back home</a></p>
+    </main>
+  </body>
+</html>
+`;
 function isHtJsxFile(id) {
   return id.endsWith(".ht.jsx") || id.endsWith(".html.jsx") || id.endsWith(".ht.tsx") || id.endsWith(".html.tsx");
 }
@@ -1354,18 +1460,12 @@ function htPages(options = {}) {
   let server = null;
   let devPages = [];
   let watcherAttached = false;
+  let userConfigFile;
+  let resolvedMode = "production";
+  let buildPipelinePromise = null;
   const cleanUrls = options.cleanUrls ?? true;
   const pagesDir = options.pagesDir ?? "src";
-  const pageExtensions = options.pageExtensions?.length ? options.pageExtensions : [
-    ".ht.js",
-    ".html.js",
-    ".ht.ts",
-    ".html.ts",
-    ".ht.jsx",
-    ".html.jsx",
-    ".ht.tsx",
-    ".html.tsx"
-  ];
+  const pageExtensions = options.pageExtensions?.length ? options.pageExtensions : DEFAULT_PAGE_EXTENSIONS;
   function logDebug(enabled, ...args) {
     if (!enabled) return;
     console.log(`[${PLUGIN_NAME}]`, ...args);
@@ -1384,13 +1484,13 @@ function htPages(options = {}) {
       entries.map((e) => e.relativePath)
     );
     if (!server) return [];
-    const loadModule = await createPageModuleLoader({
+    const loader = await createPageModuleLoader({
       mode: "dev",
       root,
       server
     });
     for (const entry of entries) {
-      const mod = await loadModule(entry.entryPath, entry.relativePath);
+      const mod = await loader.loadModule(entry.entryPath, entry.relativePath);
       modulesByEntry.set(entry.entryPath, mod);
     }
     devPages = await buildPageIndex({
@@ -1405,29 +1505,55 @@ function htPages(options = {}) {
     );
     return devPages;
   }
-  async function buildPagesPipeline() {
+  async function createBuildPipeline() {
     const entries = await discoverEntryPages(root, options);
     await writePageTypeDeclarations({
       root,
       pagesDir,
       entries
     });
-    const modulesByEntry = /* @__PURE__ */ new Map();
-    const loadModule = await createPageModuleLoader({
+    const loader = await createPageModuleLoader({
       mode: "build",
       root,
-      getPages: async () => entries
+      getPages: async () => entries,
+      configFile: userConfigFile,
+      configMode: resolvedMode
     });
-    for (const entry of entries) {
-      const mod = await loadModule(entry.entryPath, entry.relativePath);
-      modulesByEntry.set(entry.entryPath, mod);
+    try {
+      const modulesByEntry = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        const mod = await loader.loadModule(
+          entry.entryPath,
+          entry.relativePath
+        );
+        modulesByEntry.set(entry.entryPath, mod);
+      }
+      const pages = await buildPageIndex({
+        entries,
+        modulesByEntry,
+        cleanUrls
+      });
+      return { entries, modulesByEntry, pages, closeLoader: loader.close };
+    } catch (error) {
+      await loader.close();
+      throw error;
+    }
+  }
+  function getBuildPipeline() {
+    if (!buildPipelinePromise) {
+      buildPipelinePromise = createBuildPipeline();
+    }
+    return buildPipelinePromise;
+  }
+  async function closeBuildPipeline() {
+    const pending = buildPipelinePromise;
+    buildPipelinePromise = null;
+    if (!pending) return;
+    try {
+      const pipeline = await pending;
+      await pipeline.closeLoader();
+    } catch {
     }
-    const pages = await buildPageIndex({
-      entries,
-      modulesByEntry,
-      cleanUrls
-    });
-    return { entries, modulesByEntry, pages };
   }
   return {
     name: PLUGIN_NAME,
@@ -1464,7 +1590,7 @@ function htPages(options = {}) {
           return RESOLVED_VIRTUAL_JSX_DEV_RUNTIME_ID;
         }
       }
-      if (importer && isLocalPageTypesImport2(id)) {
+      if (importer && isLocalPageTypesImport(id)) {
         return `${VIRTUAL_LOCAL_TYPES_PREFIX}${importer}::${id}`;
       }
       return null;
@@ -1489,9 +1615,9 @@ export { Fragment, jsx, jsxs, jsxDEV } from ${JSON.stringify(
       }
       if (id.startsWith(RESOLVED_VIRTUAL_PAGE_HELPER_PREFIX)) {
         const importer = id.slice(RESOLVED_VIRTUAL_PAGE_HELPER_PREFIX.length);
-        const { pages } = await buildPagesPipeline();
+        const entries = await discoverEntryPages(root, options);
         const normalizedImporter = path9.resolve(importer);
-        const page = pages.find(
+        const page = entries.find(
           (candidate) => path9.resolve(candidate.absolutePath) === normalizedImporter
         );
         return generateTypedPageHelper(page);
@@ -1529,12 +1655,15 @@ export {
     },
     configResolved(resolved) {
       root = options.root ? path9.resolve(resolved.root, options.root) : resolved.root;
+      userConfigFile = resolved.configFile ?? void 0;
+      resolvedMode = resolved.mode;
       if (!hasWarnedESM) {
         warnIfNotESM(root);
         hasWarnedESM = true;
       }
     },
     async buildStart() {
+      await closeBuildPipeline();
       const entries = await discoverEntryPages(root, options);
       for (const entry of entries) {
         this.addWatchFile(entry.entryPath);
@@ -1590,8 +1719,10 @@ export {
             );
           }
         };
+        const pagesRoot = path9.join(root, pagesDir);
         const reload = (file) => {
-          if (!file.includes(`${path9.sep}${pagesDir}${path9.sep}`) && !file.includes(`/${pagesDir}/`)) {
+          const relative = path9.relative(pagesRoot, file);
+          if (relative === "" || relative.startsWith("..") || path9.isAbsolute(relative) || relative.split(path9.sep).includes("node_modules")) {
             return;
           }
           void reloadAfterChange(file);
@@ -1613,32 +1744,92 @@ export {
     },
     async generateBundle(_, bundle) {
       try {
-        const { modulesByEntry, pages } = await buildPagesPipeline();
-        const staticAssets = await collectStaticAssets({
-          root,
-          pagesDir,
-          pageExtensions
-        });
+        const { modulesByEntry, pages } = await getBuildPipeline();
         logDebug(
           options.debug,
           "emitting pages",
           pages.map((p) => p.fileName)
         );
+        const limit = pLimit(options.renderConcurrency ?? 8);
+        const batchSize = options.renderBatchSize ?? Math.max(options.renderConcurrency ?? 8, 32);
+        const renderedPages = [];
+        for (const batch of chunkArray(pages, batchSize)) {
+          await Promise.all(
+            batch.map(
+              (page) => limit(async () => {
+                const mod = modulesByEntry.get(page.entryPath);
+                if (!mod) {
+                  throw new Error(
+                    `[${PLUGIN_NAME}] Missing module for page entry: ${page.entryPath}`
+                  );
+                }
+                const html = await renderPage(page, mod, false);
+                validateHtmlAssetReferences({
+                  root,
+                  pagesDir,
+                  html,
+                  pluginName: PLUGIN_NAME,
+                  pageLabel: page.relativePath,
+                  missingAssets: options.missingAssets ?? "error"
+                });
+                renderedPages.push({ page, html });
+              })
+            )
+          );
+        }
+        const rendered404 = renderedPages.find(
+          (rendered) => rendered.page.routePath === "/404"
+        );
+        const notFoundHtml = rendered404?.html ?? DEFAULT_404_HTML;
+        logDebug(
+          options.debug,
+          rendered404 ? "generated 404.html from user page" : "generated default 404.html"
+        );
+        const referencedUrls = /* @__PURE__ */ new Set();
+        for (const { html } of renderedPages) {
+          for (const url of collectLocalAssetUrls(html)) {
+            referencedUrls.add(url);
+          }
+        }
+        for (const url of collectLocalAssetUrls(notFoundHtml)) {
+          referencedUrls.add(url);
+        }
+        const staticAssets = await collectStaticAssets({
+          root,
+          pagesDir,
+          pageExtensions
+        });
+        const isReferenced = (asset) => referencedUrls.has(`/${asset.outputFileName}`) || referencedUrls.has(`/${asset.relativePathFromSrc}`);
+        const processableAssets = [];
+        const skippedAssets = [];
+        for (const asset of staticAssets) {
+          if (asset.kind !== "process") continue;
+          if (isReferenced(asset)) {
+            processableAssets.push(asset);
+          } else {
+            skippedAssets.push(asset);
+          }
+        }
+        if (skippedAssets.length > 0) {
+          logDebug(
+            options.debug,
+            "skipping unreferenced code assets",
+            skippedAssets.map((asset) => asset.relativePathFromSrc)
+          );
+        }
         logDebug(
           options.debug,
           "emitting static assets",
-          staticAssets.map((asset) => ({
+          staticAssets.filter((asset) => asset.kind === "copy" || isReferenced(asset)).map((asset) => ({
             kind: asset.kind,
             input: asset.relativePathFromSrc,
             output: asset.outputFileName
           }))
         );
-        const limit = pLimit(options.renderConcurrency ?? 8);
-        const batchSize = options.renderBatchSize ?? Math.max(options.renderConcurrency ?? 8, 32);
         const processedOutputs = await buildProcessedStaticAssets({
           root,
           pagesDir,
-          assets: staticAssets,
+          assets: processableAssets,
           minify: true,
           sourcemap: false
         });
@@ -1658,117 +1849,28 @@ export {
             source
           });
         }
-        for (const batch of chunkArray(pages, batchSize)) {
-          await Promise.all(
-            batch.map(
-              (page) => limit(async () => {
-                const mod = modulesByEntry.get(page.entryPath);
-                if (!mod) {
-                  throw new Error(
-                    `[${PLUGIN_NAME}] Missing module for page entry: ${page.entryPath}`
-                  );
-                }
-                const html = await renderPage(page, mod, false);
-                validateHtmlAssetReferences({
-                  root,
-                  pagesDir,
-                  html,
-                  pluginName: PLUGIN_NAME,
-                  pageLabel: page.relativePath,
-                  missingAssets: options.missingAssets ?? "error"
-                });
-                this.emitFile({
-                  type: "asset",
-                  fileName: options.mapOutputPath?.(page) ?? page.fileName,
-                  source: html
-                });
-              })
-            )
-          );
-        }
-        const notFoundPage = pages.find((p) => p.routePath === "/404");
-        if (notFoundPage) {
-          const mod = modulesByEntry.get(notFoundPage.entryPath);
-          if (!mod) {
-            throw new Error(
-              `[${PLUGIN_NAME}] Missing module for 404 page entry: ${notFoundPage.entryPath}`
-            );
-          }
-          const html = await renderPage(notFoundPage, mod, false);
-          validateHtmlAssetReferences({
-            root,
-            pagesDir,
-            html,
-            pluginName: PLUGIN_NAME,
-            pageLabel: notFoundPage.relativePath,
-            missingAssets: options.missingAssets ?? "error"
-          });
+        for (const { page, html } of renderedPages) {
           this.emitFile({
             type: "asset",
-            fileName: "404.html",
+            fileName: options.mapOutputPath?.(page) ?? page.fileName,
             source: html
           });
-          logDebug(options.debug, "generated 404.html from user page");
-        } else {
-          const default404 = `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>404 - Page Not Found</title>
-    <style>
-      :root {
-        color-scheme: light dark;
-      }
-      body {
-        margin: 0;
-        font-family: system-ui, sans-serif;
-        min-height: 100vh;
-        display: grid;
-        place-items: center;
-        padding: 2rem;
-      }
-      main {
-        max-width: 40rem;
-        text-align: center;
-      }
-      h1 {
-        font-size: 3rem;
-        margin: 0 0 1rem;
-      }
-      p {
-        margin: 0.5rem 0;
-        line-height: 1.5;
-      }
-      a {
-        color: inherit;
-      }
-    </style>
-  </head>
-  <body>
-    <main>
-      <h1>404</h1>
-      <p>Page not found.</p>
-      <p><a href="/">Go back home</a></p>
-    </main>
-  </body>
-</html>
-`;
-          this.emitFile({
-            type: "asset",
-            fileName: "404.html",
-            source: default404
-          });
-          logDebug(options.debug, "generated default 404.html");
         }
-        const sitemapBase = options.site ?? "";
+        this.emitFile({
+          type: "asset",
+          fileName: "404.html",
+          source: notFoundHtml
+        });
+        const sitemapBase = (options.site ?? "").replace(/\/+$/, "");
         const sitemapRoutes = [...new Set(pages.map((p) => p.routePath))].filter(
           (route) => !route.includes(":") && !route.includes("*")
         );
         if (sitemapBase && sitemapRoutes.length > 0) {
           const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${sitemapRoutes.map((route) => `  <url><loc>${sitemapBase}${route}</loc></url>`).join("\n")}
+${sitemapRoutes.map(
+            (route) => `  <url><loc>${escapeXml(`${sitemapBase}${route}`)}</loc></url>`
+          ).join("\n")}
 </urlset>
 `;
           this.emitFile({
@@ -1781,10 +1883,11 @@ ${sitemapRoutes.map((route) => `  <url><loc>${sitemapBase}${route}</loc></url>`)
         const rss = options.rss;
         if (rss?.site) {
           const routePrefix = rss.routePrefix ?? "/blog";
+          const rssSite = rss.site.replace(/\/+$/, "");
           const rssItems = pages.filter((page) => page.routePath.startsWith(routePrefix)).map((page) => {
-            const url = `${rss.site}${page.routePath}`;
+            const url = escapeXml(`${rssSite}${page.routePath}`);
             return `  <item>
-    <title>${page.routePath}</title>
+    <title>${escapeXml(page.routePath)}</title>
     <link>${url}</link>
     <guid>${url}</guid>
   </item>`;
@@ -1792,9 +1895,9 @@ ${sitemapRoutes.map((route) => `  <url><loc>${sitemapBase}${route}</loc></url>`)
           const rssXml = `<?xml version="1.0" encoding="UTF-8"?>
 <rss version="2.0">
 <channel>
-  <title>${rss.title ?? PLUGIN_NAME}</title>
-  <link>${rss.site}</link>
-  <description>${rss.description ?? "RSS feed"}</description>
+  <title>${escapeXml(rss.title ?? PLUGIN_NAME)}</title>
+  <link>${escapeXml(rssSite)}</link>
+  <description>${escapeXml(rss.description ?? "RSS feed")}</description>
 ${rssItems}
 </channel>
 </rss>
@@ -1812,8 +1915,16 @@ ${rssItems}
           }
         }
       } finally {
-        await closePageModuleLoader();
+        await closeBuildPipeline();
+      }
+    },
+    async buildEnd(error) {
+      if (error) {
+        await closeBuildPipeline();
       }
+    },
+    async closeBundle() {
+      await closeBuildPipeline();
     }
   };
 }
@@ -1832,8 +1943,20 @@ function createDefaultCacheKey(input, init) {
   });
   return createHash("sha256").update(raw).digest("hex");
 }
+var SAFE_FILE_KEY_RE = /^[A-Za-z0-9._-]{1,200}$/;
+function toSafeFileKey(cacheKey) {
+  if (SAFE_FILE_KEY_RE.test(cacheKey)) {
+    return cacheKey;
+  }
+  return createHash("sha256").update(cacheKey).digest("hex");
+}
 function getCacheFilePath(cacheKey) {
-  return path10.join(process.cwd(), CACHE_DIR_NAME, "fetch", `${cacheKey}.json`);
+  return path10.join(
+    process.cwd(),
+    CACHE_DIR_NAME,
+    "fetch",
+    `${toSafeFileKey(cacheKey)}.json`
+  );
 }
 function getEffectiveCacheMode(mode) {
   if (mode === "memory" || mode === "fs" || mode === "none") {
@@ -1841,6 +1964,16 @@ function getEffectiveCacheMode(mode) {
   }
   return process.env.NODE_ENV === "production" ? "fs" : "memory";
 }
+var BODY_ENCODING_HEADERS = /* @__PURE__ */ new Set([
+  "content-encoding",
+  "content-length",
+  "transfer-encoding"
+]);
+function sanitizeHeaders(headers) {
+  return [...headers.entries()].filter(
+    ([name]) => !BODY_ENCODING_HEADERS.has(name.toLowerCase())
+  );
+}
 function toResponse(cached) {
   return new Response(cached.body, {
     status: cached.status,
@@ -1885,22 +2018,25 @@ async function fetchWithCache(input, init, options = {}) {
   }
   const res = await fetch(input, init);
   const body = await res.text();
-  const record = {
-    timestamp: Date.now(),
-    status: res.status,
-    statusText: res.statusText,
-    headers: [...res.headers.entries()],
-    body
-  };
-  if (cacheMode === "memory") {
-    memoryCache.set(cacheKey, record);
-  } else if (cacheMode === "fs") {
-    await fs7.writeFile(filePath, JSON.stringify(record), "utf8");
+  const headers = sanitizeHeaders(res.headers);
+  if (res.ok) {
+    const record = {
+      timestamp: Date.now(),
+      status: res.status,
+      statusText: res.statusText,
+      headers,
+      body
+    };
+    if (cacheMode === "memory") {
+      memoryCache.set(cacheKey, record);
+    } else if (cacheMode === "fs") {
+      await fs7.writeFile(filePath, JSON.stringify(record), "utf8");
+    }
   }
   return new Response(body, {
     status: res.status,
     statusText: res.statusText,
-    headers: res.headers
+    headers
   });
 }
 export {