astro 1.0.0-beta.5 → 1.0.0-beta.52

package/dist/core/build/generate.js

@@ -1,22 +1,18 @@
-import astroRemark from "@astrojs/markdown-remark";
 import fs from "fs";
 import { bgGreen, black, cyan, dim, green, magenta } from "kleur/colors";
 import npath from "path";
 import { fileURLToPath } from "url";
-import { debug, info } from "../logger/core.js";
-import { prependForwardSlash } from "../../core/path.js";
+import { joinPaths, prependForwardSlash, removeLeadingForwardSlash } from "../../core/path.js";
 import { BEFORE_HYDRATION_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { call as callEndpoint } from "../endpoint/index.js";
+import { debug, info } from "../logger/core.js";
 import { render } from "../render/core.js";
-import {
-  createLinkStylesheetElementSet,
-  createModuleScriptElementWithSrcSet
-} from "../render/ssr-element.js";
+import { createLinkStylesheetElementSet, createModuleScriptsSet } from "../render/ssr-element.js";
+import { createRequest } from "../request.js";
 import { getOutputFilename, isBuildingToSSR } from "../util.js";
 import { getOutFile, getOutFolder } from "./common.js";
 import { eachPageData, getPageDataByComponent } from "./internal.js";
 import { getTimeStat } from "./util.js";
-import { createRequest } from "../request.js";
 const MAX_CONCURRENT_RENDERS = 1;
 function* throttle(max, inPaths) {
   let tmp = [];
@@ -35,6 +31,9 @@ function* throttle(max, inPaths) {
     yield tmp;
   }
 }
+function shouldSkipDraft(pageModule, astroConfig) {
+  return !astroConfig.markdown.drafts && "frontmatter" in pageModule && pageModule.frontmatter.draft === true;
+}
 function rootRelativeFacadeId(facadeId, astroConfig) {
   return facadeId.slice(fileURLToPath(astroConfig.root).length);
 }
@@ -69,16 +68,20 @@ async function generatePage(opts, internals, pageData, ssrEntry) {
   const renderers = ssrEntry.renderers;
   const pageInfo = getPageDataByComponent(internals, pageData.route.component);
   const linkIds = Array.from((pageInfo == null ? void 0 : pageInfo.css) ?? []);
-  const hoistedId = (pageInfo == null ? void 0 : pageInfo.hoistedScript) ?? null;
+  const scripts = (pageInfo == null ? void 0 : pageInfo.hoistedScript) ?? null;
   const pageModule = ssrEntry.pageMap.get(pageData.component);
   if (!pageModule) {
     throw new Error(`Unable to find the module for ${pageData.component}. This is unexpected and likely a bug in Astro, please report.`);
   }
+  if (shouldSkipDraft(pageModule, opts.astroConfig)) {
+    info(opts.logging, null, `${magenta("\u26A0\uFE0F")}  Skipping draft ${pageData.route.component}`);
+    return;
+  }
   const generationOptions = {
     pageData,
     internals,
     linkIds,
-    hoistedId,
+    scripts,
     mod: pageModule,
     renderers
   };
@@ -99,15 +102,16 @@ function addPageName(pathname, opts) {
   opts.pageNames.push(pathname.replace(/\/?$/, "/").replace(/^\//, ""));
 }
 async function generatePath(pathname, opts, gopts) {
+  var _a;
   const { astroConfig, logging, origin, routeCache } = opts;
-  const { mod, internals, linkIds, hoistedId, pageData, renderers } = gopts;
+  const { mod, internals, linkIds, scripts: hoistedScripts, pageData, renderers } = gopts;
   if (pageData.route.type === "page") {
     addPageName(pathname, opts);
   }
   debug("build", `Generating: ${pathname}`);
-  const site = astroConfig.site;
+  const site = astroConfig.base !== "/" ? joinPaths(((_a = astroConfig.site) == null ? void 0 : _a.toString()) || "http://localhost/", astroConfig.base) : astroConfig.site;
   const links = createLinkStylesheetElementSet(linkIds.reverse(), site);
-  const scripts = createModuleScriptElementWithSrcSet(hoistedId ? [hoistedId] : [], site);
+  const scripts = createModuleScriptsSet(hoistedScripts ? [hoistedScripts] : [], site);
   for (const script of astroConfig._ctx.scripts) {
     if (script.stage === "head-inline") {
       scripts.add({
@@ -117,12 +121,11 @@ async function generatePath(pathname, opts, gopts) {
     }
   }
   const ssr = isBuildingToSSR(opts.astroConfig);
-  const url = new URL(origin + pathname);
+  const url = new URL(opts.astroConfig.base + removeLeadingForwardSlash(pathname), origin);
   const options = {
-    legacyBuild: false,
     links,
     logging,
-    markdownRender: [astroRemark, astroConfig.markdown],
+    markdown: astroConfig.markdown,
     mod,
     origin,
     pathname,
@@ -136,9 +139,7 @@ async function generatePath(pathname, opts, gopts) {
         }
         throw new Error(`Cannot find the built path for ${specifier}`);
       }
-      const relPath = npath.posix.relative(pathname, "/" + hashedFilePath);
-      const fullyRelativePath = relPath[0] === "." ? relPath : "./" + relPath;
-      return fullyRelativePath;
+      return prependForwardSlash(npath.posix.join(astroConfig.base, hashedFilePath));
     },
     request: createRequest({ url, headers: new Headers(), logging, ssr }),
     route: pageData.route,
@@ -162,6 +163,7 @@ async function generatePath(pathname, opts, gopts) {
   }
   const outFolder = getOutFolder(astroConfig, pathname, pageData.route.type);
   const outFile = getOutFile(astroConfig, outFolder, pathname, pageData.route.type);
+  pageData.route.distURL = outFile;
   await fs.promises.mkdir(outFolder, { recursive: true });
   await fs.promises.writeFile(outFile, body, "utf-8");
 }

package/dist/core/build/graph.js

@@ -0,0 +1,27 @@
+import { resolvedPagesVirtualModuleId } from "../app/index.js";
+function* walkParentInfos(id, ctx, seen = /* @__PURE__ */ new Set()) {
+  seen.add(id);
+  const info = ctx.getModuleInfo(id);
+  if (info) {
+    yield info;
+  }
+  const importers = ((info == null ? void 0 : info.importers) || []).concat((info == null ? void 0 : info.dynamicImporters) || []);
+  for (const imp of importers) {
+    if (seen.has(imp)) {
+      continue;
+    }
+    yield* walkParentInfos(imp, ctx, seen);
+  }
+}
+function* getTopLevelPages(id, ctx) {
+  for (const info of walkParentInfos(id, ctx)) {
+    const importers = ((info == null ? void 0 : info.importers) || []).concat((info == null ? void 0 : info.dynamicImporters) || []);
+    if (importers.length <= 2 && importers[0] === resolvedPagesVirtualModuleId) {
+      yield info.id;
+    }
+  }
+}
+export {
+  getTopLevelPages,
+  walkParentInfos
+};

package/dist/core/build/index.js

@@ -1,31 +1,24 @@
 import fs from "fs";
 import * as colors from "kleur/colors";
-import { apply as applyPolyfill } from "../polyfill.js";
 import { performance } from "perf_hooks";
 import * as vite from "vite";
-import { createVite } from "../create-vite.js";
-import {
-  debug,
-  info,
-  levels,
-  timerMessage,
-  warnIfUsingExperimentalSSR
-} from "../logger/core.js";
-import { nodeLogOptions } from "../logger/node.js";
-import { createRouteManifest } from "../routing/index.js";
-import { collectPagesData } from "./page-data.js";
-import { staticBuild } from "./static-build.js";
-import { RouteCache } from "../render/route-cache.js";
 import {
   runHookBuildDone,
   runHookBuildStart,
   runHookConfigDone,
   runHookConfigSetup
 } from "../../integrations/index.js";
-import { getTimeStat } from "./util.js";
-import { createSafeError, isBuildingToSSR } from "../util.js";
+import { createVite } from "../create-vite.js";
 import { fixViteErrorMessage } from "../errors.js";
-async function build(config, options = { logging: nodeLogOptions }) {
+import { debug, info, levels, timerMessage, warnIfUsingExperimentalSSR } from "../logger/core.js";
+import { apply as applyPolyfill } from "../polyfill.js";
+import { RouteCache } from "../render/route-cache.js";
+import { createRouteManifest } from "../routing/index.js";
+import { createSafeError, isBuildingToSSR } from "../util.js";
+import { collectPagesData } from "./page-data.js";
+import { staticBuild } from "./static-build.js";
+import { getTimeStat } from "./util.js";
+async function build(config, options) {
   applyPolyfill();
   const builder = new AstroBuilder(config, options);
   await builder.run();
@@ -40,7 +33,7 @@ class AstroBuilder {
     this.logging = options.logging;
     this.routeCache = new RouteCache(this.logging);
     this.origin = config.site ? new URL(config.site).origin : `http://localhost:${config.server.port}`;
-    this.manifest = createRouteManifest({ config }, this.logging);
+    this.manifest = { routes: [] };
     this.timer = {};
   }
   async setup() {
@@ -49,6 +42,7 @@ class AstroBuilder {
     this.timer.init = performance.now();
     this.timer.viteStart = performance.now();
     this.config = await runHookConfigSetup({ config: this.config, command: "build" });
+    this.manifest = createRouteManifest({ config: this.config }, this.logging);
     const viteConfig = await createVite({
       mode: this.mode,
       server: {
@@ -85,15 +79,6 @@ class AstroBuilder {
       viteServer,
       ssr: isBuildingToSSR(this.config)
     });
-    Object.entries(allPages).forEach(([page, data]) => {
-      if ("frontmatter" in data.preload[1]) {
-        const frontmatter = data.preload[1].frontmatter;
-        if (Boolean(frontmatter.draft) && !this.config.markdown.drafts) {
-          debug("build", timerMessage(`Skipping draft page ${page}`, this.timer.loadStart));
-          delete allPages[page];
-        }
-      }
-    });
     debug("build", timerMessage("All pages loaded", this.timer.loadStart));
     const pageNames = [];
     this.timer.buildStart = performance.now();
@@ -141,7 +126,6 @@ class AstroBuilder {
     try {
       await this.build(setupData);
     } catch (_err) {
-      debugger;
       throw fixViteErrorMessage(createSafeError(_err), setupData.viteServer);
     }
   }
@@ -151,7 +135,6 @@ class AstroBuilder {
     pageCount,
     buildMode
   }) {
-    const buildTime = performance.now() - timeStart;
     const total = getTimeStat(timeStart, performance.now());
     let messages = [];
     if (buildMode === "static") {

package/dist/core/build/internal.js

@@ -1,3 +1,4 @@
+import { prependForwardSlash } from "../path.js";
 import { viteID } from "../util.js";
 function createBuildInternals() {
   const pureCSSChunks = /* @__PURE__ */ new Set();
@@ -5,15 +6,19 @@ function createBuildInternals() {
   const astroStyleMap = /* @__PURE__ */ new Map();
   const astroPageStyleMap = /* @__PURE__ */ new Map();
   const hoistedScriptIdToHoistedMap = /* @__PURE__ */ new Map();
+  const hoistedScriptIdToPagesMap = /* @__PURE__ */ new Map();
   return {
     pureCSSChunks,
-    chunkToReferenceIdMap,
-    astroStyleMap,
-    astroPageStyleMap,
     hoistedScriptIdToHoistedMap,
+    hoistedScriptIdToPagesMap,
     entrySpecifierToBundleMap: /* @__PURE__ */ new Map(),
     pagesByComponent: /* @__PURE__ */ new Map(),
-    pagesByViteID: /* @__PURE__ */ new Map()
+    pagesByViteID: /* @__PURE__ */ new Map(),
+    pagesByClientOnly: /* @__PURE__ */ new Map(),
+    discoveredHydratedComponents: /* @__PURE__ */ new Set(),
+    discoveredClientOnlyComponents: /* @__PURE__ */ new Set(),
+    discoveredScripts: /* @__PURE__ */ new Set(),
+    staticFiles: /* @__PURE__ */ new Set()
   };
 }
 function trackPageData(internals, component, pageData, componentModuleId, componentURL) {
@@ -21,6 +26,18 @@ function trackPageData(internals, component, pageData, componentModuleId, compon
   internals.pagesByComponent.set(component, pageData);
   internals.pagesByViteID.set(viteID(componentURL), pageData);
 }
+function trackClientOnlyPageDatas(internals, pageData, clientOnlys) {
+  for (const clientOnlyComponent of clientOnlys) {
+    let pageDataSet;
+    if (internals.pagesByClientOnly.has(clientOnlyComponent)) {
+      pageDataSet = internals.pagesByClientOnly.get(clientOnlyComponent);
+    } else {
+      pageDataSet = /* @__PURE__ */ new Set();
+      internals.pagesByClientOnly.set(clientOnlyComponent, pageDataSet);
+    }
+    pageDataSet.add(pageData);
+  }
+}
 function* getPageDatasByChunk(internals, chunk) {
   const pagesByViteID = internals.pagesByViteID;
   for (const [modulePath] of Object.entries(chunk.modules)) {
@@ -29,6 +46,18 @@ function* getPageDatasByChunk(internals, chunk) {
     }
   }
 }
+function* getPageDatasByClientOnlyID(internals, viteid) {
+  const pagesByClientOnly = internals.pagesByClientOnly;
+  if (pagesByClientOnly.size) {
+    const pathname = `/@fs${prependForwardSlash(viteid)}`;
+    const pageBuildDatas = pagesByClientOnly.get(pathname);
+    if (pageBuildDatas) {
+      for (const pageData of pageBuildDatas) {
+        yield pageData;
+      }
+    }
+  }
+}
 function getPageDataByComponent(internals, component) {
   if (internals.pagesByComponent.has(component)) {
     return internals.pagesByComponent.get(component);
@@ -53,6 +82,8 @@ export {
   getPageDataByComponent,
   getPageDataByViteID,
   getPageDatasByChunk,
+  getPageDatasByClientOnlyID,
   hasPageDataByViteID,
+  trackClientOnlyPageDatas,
   trackPageData
 };

package/dist/core/build/page-data.js

@@ -1,16 +1,16 @@
 import { info } from "../logger/core.js";
-import { fileURLToPath } from "url";
 import * as colors from "kleur/colors";
+import { fileURLToPath } from "url";
 import { debug } from "../logger/core.js";
-import { preload as ssrPreload } from "../render/dev/index.js";
-import { generateRssFunction } from "../render/rss.js";
+import { removeTrailingForwardSlash } from "../path.js";
 import { callGetStaticPaths } from "../render/route-cache.js";
+import { matchRoute } from "../routing/match.js";
 import { isBuildingToSSR } from "../util.js";
 async function collectPagesData(opts) {
-  var _a;
   const { astroConfig, logging, manifest, origin, routeCache, viteServer } = opts;
   const assets = {};
   const allPages = {};
+  const builtPaths = /* @__PURE__ */ new Set();
   const buildMode = isBuildingToSSR(astroConfig) ? "ssr" : "static";
   const dataCollectionLogTimeout = setInterval(() => {
     info(opts.logging, "build", "The data collection step may take longer for larger projects...");
@@ -22,33 +22,22 @@ async function collectPagesData(opts) {
         info(opts.logging, "build", `${colors.bold(route.component)} is taking a bit longer to import. This is common for larger "Astro.glob(...)" or "import.meta.globEager(...)" calls, for instance. Hang tight!`);
         clearInterval(routeCollectionLogTimeout);
       }, 1e4);
+      builtPaths.add(route.pathname);
       allPages[route.component] = {
         component: route.component,
         route,
         paths: [route.pathname],
         moduleSpecifier: "",
         css: /* @__PURE__ */ new Set(),
-        hoistedScript: void 0,
-        scripts: /* @__PURE__ */ new Set(),
-        preload: await ssrPreload({
-          astroConfig,
-          filePath: new URL(`./${route.component}`, astroConfig.root),
-          viteServer
-        }).then((routes) => {
-          clearInterval(routeCollectionLogTimeout);
-          if (buildMode === "static") {
-            const html = `${route.pathname}`.replace(/\/?$/, "/index.html");
-            debug("build", `\u251C\u2500\u2500 ${colors.bold(colors.green("\u2714"))} ${route.component} \u2192 ${colors.yellow(html)}`);
-          } else {
-            debug("build", `\u251C\u2500\u2500 ${colors.bold(colors.green("\u2714"))} ${route.component}`);
-          }
-          return routes;
-        }).catch((err) => {
-          clearInterval(routeCollectionLogTimeout);
-          debug("build", `\u251C\u2500\u2500 ${colors.bold(colors.red("\u2718"))} ${route.component}`);
-          throw err;
-        })
+        hoistedScript: void 0
       };
+      clearInterval(routeCollectionLogTimeout);
+      if (buildMode === "static") {
+        const html = `${route.pathname}`.replace(/\/?$/, "/index.html");
+        debug("build", `\u251C\u2500\u2500 ${colors.bold(colors.green("\u2714"))} ${route.component} \u2192 ${colors.yellow(html)}`);
+      } else {
+        debug("build", `\u251C\u2500\u2500 ${colors.bold(colors.green("\u2714"))} ${route.component}`);
+      }
       continue;
     }
     const result = await getStaticPathsForRoute(opts, route).then((_result) => {
@@ -59,44 +48,24 @@ async function collectPagesData(opts) {
       debug("build", `\u251C\u2500\u2500 ${colors.bold(colors.red("\u2717"))} ${route.component}`);
       throw err;
     });
-    const rssFn = generateRssFunction(astroConfig.site, route);
-    for (const rssCallArg of result.rss) {
-      const rssResult = rssFn(rssCallArg);
-      if (rssResult.xml) {
-        const { url, content } = rssResult.xml;
-        if (content) {
-          const rssFile = new URL(url.replace(/^\/?/, "./"), astroConfig.outDir);
-          if (assets[fileURLToPath(rssFile)]) {
-            throw new Error(`[getStaticPaths] RSS feed ${url} already exists.
-Use \`rss(data, {url: '...'})\` to choose a unique, custom URL. (${route.component})`);
-          }
-          assets[fileURLToPath(rssFile)] = content;
-        }
+    const finalPaths = result.staticPaths.map((staticPath) => staticPath.params && route.generate(staticPath.params)).filter((staticPath) => {
+      if (!staticPath) {
+        return false;
       }
-      if ((_a = rssResult.xsl) == null ? void 0 : _a.content) {
-        const { url, content } = rssResult.xsl;
-        const stylesheetFile = new URL(url.replace(/^\/?/, "./"), astroConfig.outDir);
-        if (assets[fileURLToPath(stylesheetFile)]) {
-          throw new Error(`[getStaticPaths] RSS feed stylesheet ${url} already exists.
-Use \`rss(data, {stylesheet: '...'})\` to choose a unique, custom URL. (${route.component})`);
-        }
-        assets[fileURLToPath(stylesheetFile)] = content;
+      if (!builtPaths.has(removeTrailingForwardSlash(staticPath))) {
+        return true;
       }
-    }
-    const finalPaths = result.staticPaths.map((staticPath) => staticPath.params && route.generate(staticPath.params)).filter(Boolean);
+      const matchedRoute = matchRoute(staticPath, manifest);
+      return matchedRoute === route;
+    });
+    finalPaths.map((staticPath) => builtPaths.add(removeTrailingForwardSlash(staticPath)));
     allPages[route.component] = {
       component: route.component,
       route,
       paths: finalPaths,
       moduleSpecifier: "",
       css: /* @__PURE__ */ new Set(),
-      hoistedScript: void 0,
-      scripts: /* @__PURE__ */ new Set(),
-      preload: await ssrPreload({
-        astroConfig,
-        filePath: new URL(`./${route.component}`, astroConfig.root),
-        viteServer
-      })
+      hoistedScript: void 0
     };
   }
   clearInterval(dataCollectionLogTimeout);

package/dist/core/build/static-build.js

@@ -20,27 +20,26 @@ var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import glob from "fast-glob";
 import fs from "fs";
 import { bgGreen, bgMagenta, black, dim } from "kleur/colors";
-import npath from "path";
 import { fileURLToPath } from "url";
 import * as vite from "vite";
 import { createBuildInternals } from "../../core/build/internal.js";
-import { info } from "../logger/core.js";
 import { prependForwardSlash } from "../../core/path.js";
 import { emptyDir, removeDir } from "../../core/util.js";
+import { runHookBuildSetup } from "../../integrations/index.js";
 import { rollupPluginAstroBuildCSS } from "../../vite-plugin-build-css/index.js";
-import { vitePluginHoistedScripts } from "./vite-plugin-hoisted-scripts.js";
-import { vitePluginInternals } from "./vite-plugin-internals.js";
-import { vitePluginSSR } from "./vite-plugin-ssr.js";
-import { vitePluginPages } from "./vite-plugin-pages.js";
+import { info } from "../logger/core.js";
+import { isBuildingToSSR } from "../util.js";
 import { generatePages } from "./generate.js";
 import { trackPageData } from "./internal.js";
-import { isBuildingToSSR } from "../util.js";
-import { runHookBuildSetup } from "../../integrations/index.js";
 import { getTimeStat } from "./util.js";
+import { vitePluginAnalyzer } from "./vite-plugin-analyzer.js";
+import { vitePluginHoistedScripts } from "./vite-plugin-hoisted-scripts.js";
+import { vitePluginInternals } from "./vite-plugin-internals.js";
+import { vitePluginPages } from "./vite-plugin-pages.js";
+import { injectManifest, vitePluginSSR } from "./vite-plugin-ssr.js";
 async function staticBuild(opts) {
   const { allPages, astroConfig } = opts;
   const pageInput = /* @__PURE__ */ new Set();
-  const jsInput = /* @__PURE__ */ new Set();
   const facadeIdToPageDataMap = /* @__PURE__ */ new Map();
   const internals = createBuildInternals();
   const timer = {};
@@ -49,40 +48,31 @@ async function staticBuild(opts) {
     const astroModuleURL = new URL("./" + component, astroConfig.root);
     const astroModuleId = prependForwardSlash(component);
     trackPageData(internals, component, pageData, astroModuleId, astroModuleURL);
-    if (pageData.route.type === "page") {
-      const [renderers, mod] = pageData.preload;
-      const metadata = mod.$$metadata;
-      const topLevelImports = /* @__PURE__ */ new Set([
-        ...metadata.hydratedComponentPaths(),
-        ...metadata.clientOnlyComponentPaths(),
-        ...metadata.hydrationDirectiveSpecifiers(),
-        ...renderers.filter((renderer) => !!renderer.clientEntrypoint).map((renderer) => renderer.clientEntrypoint)
-      ]);
-      const hoistedScripts = new Set(metadata.hoistedScriptPaths());
-      if (hoistedScripts.size) {
-        const moduleId = npath.posix.join(astroModuleId, "hoisted.js");
-        internals.hoistedScriptIdToHoistedMap.set(moduleId, hoistedScripts);
-        topLevelImports.add(moduleId);
-      }
-      for (const specifier of topLevelImports) {
-        jsInput.add(specifier);
-      }
-    }
     pageInput.add(astroModuleId);
     facadeIdToPageDataMap.set(fileURLToPath(astroModuleURL), pageData);
   }
   emptyDir(astroConfig.outDir, new Set(".git"));
-  timer.clientBuild = performance.now();
-  await clientBuild(opts, internals, jsInput);
   timer.ssr = performance.now();
-  info(opts.logging, "build", "Building for SSR...");
+  info(opts.logging, "build", isBuildingToSSR(astroConfig) ? "Building SSR entrypoints..." : "Building entrypoints for prerendering...");
   const ssrResult = await ssrBuild(opts, internals, pageInput);
   info(opts.logging, "build", dim(`Completed in ${getTimeStat(timer.ssr, performance.now())}.`));
+  const clientInput = /* @__PURE__ */ new Set([
+    ...internals.discoveredHydratedComponents,
+    ...internals.discoveredClientOnlyComponents,
+    ...astroConfig._ctx.renderers.map((r) => r.clientEntrypoint).filter((a) => a),
+    ...internals.discoveredScripts
+  ]);
+  timer.clientBuild = performance.now();
+  await clientBuild(opts, internals, clientInput);
   timer.generate = performance.now();
   if (opts.buildConfig.staticMode) {
-    await generatePages(ssrResult, opts, internals, facadeIdToPageDataMap);
-    await cleanSsrOutput(opts);
+    try {
+      await generatePages(ssrResult, opts, internals, facadeIdToPageDataMap);
+    } finally {
+      await cleanSsrOutput(opts);
+    }
   } else {
+    await injectManifest(opts, internals);
     info(opts.logging, null, `
 ${bgMagenta(black(" finalizing server assets "))}
 `);
@@ -90,25 +80,30 @@ ${bgMagenta(black(" finalizing server assets "))}
   }
 }
 async function ssrBuild(opts, internals, input) {
+  var _a, _b, _c, _d;
   const { astroConfig, viteConfig } = opts;
   const ssr = isBuildingToSSR(astroConfig);
   const out = ssr ? opts.buildConfig.server : astroConfig.outDir;
   const viteBuildConfig = {
-    logLevel: "error",
+    logLevel: opts.viteConfig.logLevel ?? "error",
     mode: "production",
     css: viteConfig.css,
+    optimizeDeps: {
+      include: [...((_a = viteConfig.optimizeDeps) == null ? void 0 : _a.include) ?? []],
+      exclude: [...((_b = viteConfig.optimizeDeps) == null ? void 0 : _b.exclude) ?? []]
+    },
     build: __spreadProps(__spreadValues({}, viteConfig.build), {
       emptyOutDir: false,
       manifest: false,
       outDir: fileURLToPath(out),
       rollupOptions: {
         input: [],
-        output: {
+        output: __spreadValues({
           format: "esm",
           entryFileNames: opts.buildConfig.serverEntry,
-          chunkFileNames: "chunks/chunk.[hash].mjs",
-          assetFileNames: "assets/asset.[hash][extname]"
-        }
+          chunkFileNames: "chunks/[name].[hash].mjs",
+          assetFileNames: "assets/[name].[hash][extname]"
+        }, (_d = (_c = viteConfig.build) == null ? void 0 : _c.rollupOptions) == null ? void 0 : _d.output)
       },
       ssr: true,
       target: "esnext",
@@ -121,23 +116,30 @@ async function ssrBuild(opts, internals, input) {
       vitePluginPages(opts, internals),
       rollupPluginAstroBuildCSS({
         internals,
-        legacy: false
+        target: "server"
       }),
       ...viteConfig.plugins || [],
-      isBuildingToSSR(opts.astroConfig) && vitePluginSSR(opts, internals, opts.astroConfig._ctx.adapter)
+      isBuildingToSSR(opts.astroConfig) && vitePluginSSR(opts, internals, opts.astroConfig._ctx.adapter),
+      vitePluginAnalyzer(opts.astroConfig, internals)
     ],
     publicDir: ssr ? false : viteConfig.publicDir,
     root: viteConfig.root,
     envPrefix: "PUBLIC_",
     server: viteConfig.server,
-    base: astroConfig.site ? new URL(astroConfig.site).pathname : "/",
+    base: astroConfig.base,
     ssr: viteConfig.ssr,
     resolve: viteConfig.resolve
   };
-  await runHookBuildSetup({ config: astroConfig, vite: viteBuildConfig, target: "server" });
+  await runHookBuildSetup({
+    config: astroConfig,
+    pages: internals.pagesByComponent,
+    vite: viteBuildConfig,
+    target: "server"
+  });
   return await vite.build(viteBuildConfig);
 }
 async function clientBuild(opts, internals, input) {
+  var _a, _b, _c, _d;
   const { astroConfig, viteConfig } = opts;
   const timer = performance.now();
   const ssr = isBuildingToSSR(astroConfig);
@@ -154,18 +156,22 @@ ${bgGreen(black(" building client "))}`);
     logLevel: "info",
     mode: "production",
     css: viteConfig.css,
+    optimizeDeps: {
+      include: [...((_a = viteConfig.optimizeDeps) == null ? void 0 : _a.include) ?? []],
+      exclude: [...((_b = viteConfig.optimizeDeps) == null ? void 0 : _b.exclude) ?? []]
+    },
     build: {
       emptyOutDir: false,
       minify: "esbuild",
       outDir: fileURLToPath(out),
       rollupOptions: {
         input: Array.from(input),
-        output: {
+        output: __spreadValues({
           format: "esm",
-          entryFileNames: "entry.[hash].js",
-          chunkFileNames: "chunks/chunk.[hash].js",
-          assetFileNames: "assets/asset.[hash][extname]"
-        },
+          entryFileNames: "[name].[hash].js",
+          chunkFileNames: "chunks/[name].[hash].js",
+          assetFileNames: "assets/[name].[hash][extname]"
+        }, (_d = (_c = viteConfig.build) == null ? void 0 : _c.rollupOptions) == null ? void 0 : _d.output),
         preserveEntrySignatures: "exports-only"
       },
       target: "esnext"
@@ -175,7 +181,7 @@ ${bgGreen(black(" building client "))}`);
       vitePluginHoistedScripts(astroConfig, internals),
       rollupPluginAstroBuildCSS({
         internals,
-        legacy: false
+        target: "client"
       }),
       ...viteConfig.plugins || []
     ],
@@ -185,7 +191,12 @@ ${bgGreen(black(" building client "))}`);
     server: viteConfig.server,
     base: astroConfig.base
   };
-  await runHookBuildSetup({ config: astroConfig, vite: viteBuildConfig, target: "client" });
+  await runHookBuildSetup({
+    config: astroConfig,
+    pages: internals.pagesByComponent,
+    vite: viteBuildConfig,
+    target: "client"
+  });
   const buildResult = await vite.build(viteBuildConfig);
   info(opts.logging, null, dim(`Completed in ${getTimeStat(timer, performance.now())}.
 `));
@@ -204,11 +215,11 @@ async function copyFiles(fromFolder, toFolder) {
   const files = await glob("**/*", {
     cwd: fileURLToPath(fromFolder)
   });
-  await fs.promises.mkdir(toFolder, { recursive: true });
   await Promise.all(files.map(async (filename) => {
     const from = new URL(filename, fromFolder);
     const to = new URL(filename, toFolder);
-    return fs.promises.copyFile(from, to);
+    const lastFolder = new URL("./", to);
+    return fs.promises.mkdir(lastFolder, { recursive: true }).then(() => fs.promises.copyFile(from, to));
   }));
 }
 async function ssrMoveAssets(opts) {