astro 0.25.0-next.2 → 0.25.0-next.3

package/components/Markdown.astro

@@ -24,8 +24,6 @@ let { content, class: className } = Astro.props as InternalProps;
 let html = null;
 let htmlContent = '';
 
-const { privateRenderMarkdownDoNotUse: renderMarkdown } = Astro as any;
-
 // If no content prop provided, use the slot.
 if (!content) {
 	content = await Astro.slots.render('default');
@@ -35,7 +33,7 @@ if (!content) {
 }
 
 if (content) {
-	htmlContent = await renderMarkdown(content, {
+	htmlContent = await (Astro as any).__renderMarkdown(content, {
 		mode: 'md',
 		$: {
 			scopedClassName: className,

package/components/index.js

@@ -1,4 +1,3 @@
 export { default as Code } from './Code.astro';
 export { default as Debug } from './Debug.astro';
 export { default as Markdown } from './Markdown.astro';
-export { default as Prism } from './Prism.astro';

package/dist/adapter-ssg/index.js

@@ -0,0 +1,22 @@
+function getAdapter() {
+  return {
+    name: "@astrojs/ssg"
+  };
+}
+function createIntegration() {
+  return {
+    name: "@astrojs/ssg",
+    hooks: {
+      "astro:config:done": ({ setAdapter }) => {
+        setAdapter(getAdapter());
+      },
+      "astro:build:start": ({ buildConfig }) => {
+        buildConfig.staticMode = true;
+      }
+    }
+  };
+}
+export {
+  createIntegration as default,
+  getAdapter
+};

package/dist/cli/index.js

@@ -39,7 +39,7 @@ function printHelp() {
     console.log();
   }
   function headline(name, tagline) {
-    console.log(`  ${colors.bgGreen(colors.black(` ${name} `))} ${colors.green(`v${"0.25.0-next.2"}`)} ${tagline}`);
+    console.log(`  ${colors.bgGreen(colors.black(` ${name} `))} ${colors.green(`v${"0.25.0-next.3"}`)} ${tagline}`);
   }
   function title(label) {
     console.log(`  ${colors.bgWhite(colors.black(` ${label} `))}`);
@@ -65,7 +65,7 @@ function printHelp() {
   }
 }
 async function printVersion() {
-  const version = "0.25.0-next.2";
+  const version = "0.25.0-next.3";
   console.log();
   console.log(`  ${colors.bgGreen(colors.black(` astro `))} ${colors.green(`v${version}`)}`);
 }

package/dist/core/app/index.js

@@ -1,22 +1,3 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -39,31 +20,31 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
-var _manifest, _manifestData, _rootFolder, _routeDataToRouteInfo, _routeCache, _renderersPromise, _loadRenderers, loadRenderers_fn, _loadModule, loadModule_fn;
+var _manifest, _manifestData, _routeDataToRouteInfo, _routeCache, _encoder, _renderPage, renderPage_fn, _callEndpoint, callEndpoint_fn;
+import mime from "mime";
 import { defaultLogOptions } from "../logger.js";
+import { deserializeManifest } from "./common.js";
 import { matchRoute } from "../routing/match.js";
 import { render } from "../render/core.js";
+import { call as callEndpoint } from "../endpoint/index.js";
 import { RouteCache } from "../render/route-cache.js";
 import { createLinkStylesheetElementSet, createModuleScriptElementWithSrcSet } from "../render/ssr-element.js";
 import { prependForwardSlash } from "../path.js";
 class App {
-  constructor(manifest, rootFolder) {
-    __privateAdd(this, _loadRenderers);
-    __privateAdd(this, _loadModule);
+  constructor(manifest) {
+    __privateAdd(this, _renderPage);
+    __privateAdd(this, _callEndpoint);
     __privateAdd(this, _manifest, void 0);
     __privateAdd(this, _manifestData, void 0);
-    __privateAdd(this, _rootFolder, void 0);
     __privateAdd(this, _routeDataToRouteInfo, void 0);
     __privateAdd(this, _routeCache, void 0);
-    __privateAdd(this, _renderersPromise, void 0);
+    __privateAdd(this, _encoder, new TextEncoder());
     __privateSet(this, _manifest, manifest);
     __privateSet(this, _manifestData, {
       routes: manifest.routes.map((route) => route.routeData)
     });
-    __privateSet(this, _rootFolder, rootFolder);
     __privateSet(this, _routeDataToRouteInfo, new Map(manifest.routes.map((route) => [route.routeData, route])));
     __privateSet(this, _routeCache, new RouteCache(defaultLogOptions));
-    __privateSet(this, _renderersPromise, __privateMethod(this, _loadRenderers, loadRenderers_fn).call(this));
   }
   match(request) {
     const url = new URL(request.url);
@@ -79,69 +60,97 @@ class App {
         });
       }
     }
-    const manifest = __privateGet(this, _manifest);
-    const info = __privateGet(this, _routeDataToRouteInfo).get(routeData);
-    const [mod, renderers] = await Promise.all([__privateMethod(this, _loadModule, loadModule_fn).call(this, info.file), __privateGet(this, _renderersPromise)]);
-    const url = new URL(request.url);
-    const links = createLinkStylesheetElementSet(info.links, manifest.site);
-    const scripts = createModuleScriptElementWithSrcSet(info.scripts, manifest.site);
-    const result = await render({
-      legacyBuild: false,
-      links,
-      logging: defaultLogOptions,
-      markdownRender: manifest.markdown.render,
-      mod,
-      origin: url.origin,
-      pathname: url.pathname,
-      scripts,
-      renderers,
-      async resolve(specifier) {
-        if (!(specifier in manifest.entryModules)) {
-          throw new Error(`Unable to resolve [${specifier}]`);
-        }
-        const bundlePath = manifest.entryModules[specifier];
-        return prependForwardSlash(bundlePath);
-      },
-      route: routeData,
-      routeCache: __privateGet(this, _routeCache),
-      site: __privateGet(this, _manifest).site,
-      ssr: true,
-      method: info.routeData.type === "endpoint" ? "" : "GET",
-      headers: request.headers
-    });
-    if (result.type === "response") {
-      return result.response;
+    const mod = __privateGet(this, _manifest).pageMap.get(routeData.component);
+    if (routeData.type === "page") {
+      return __privateMethod(this, _renderPage, renderPage_fn).call(this, request, routeData, mod);
+    } else if (routeData.type === "endpoint") {
+      return __privateMethod(this, _callEndpoint, callEndpoint_fn).call(this, request, routeData, mod);
+    } else {
+      throw new Error(`Unsupported route type [${routeData.type}].`);
     }
-    let html = result.html;
-    return new Response(html, {
-      status: 200
-    });
   }
 }
 _manifest = new WeakMap();
 _manifestData = new WeakMap();
-_rootFolder = new WeakMap();
 _routeDataToRouteInfo = new WeakMap();
 _routeCache = new WeakMap();
-_renderersPromise = new WeakMap();
-_loadRenderers = new WeakSet();
-loadRenderers_fn = async function() {
-  return await Promise.all(__privateGet(this, _manifest).renderers.map(async (renderer) => {
-    const mod = await import(renderer.serverEntrypoint);
-    return __spreadProps(__spreadValues({}, renderer), { ssr: mod.default });
-  }));
+_encoder = new WeakMap();
+_renderPage = new WeakSet();
+renderPage_fn = async function(request, routeData, mod) {
+  const url = new URL(request.url);
+  const manifest = __privateGet(this, _manifest);
+  const renderers = manifest.renderers;
+  const info = __privateGet(this, _routeDataToRouteInfo).get(routeData);
+  const links = createLinkStylesheetElementSet(info.links, manifest.site);
+  const scripts = createModuleScriptElementWithSrcSet(info.scripts, manifest.site);
+  const result = await render({
+    legacyBuild: false,
+    links,
+    logging: defaultLogOptions,
+    markdownRender: manifest.markdown.render,
+    mod,
+    origin: url.origin,
+    pathname: url.pathname,
+    scripts,
+    renderers,
+    async resolve(specifier) {
+      if (!(specifier in manifest.entryModules)) {
+        throw new Error(`Unable to resolve [${specifier}]`);
+      }
+      const bundlePath = manifest.entryModules[specifier];
+      return bundlePath.startsWith("data:") ? bundlePath : prependForwardSlash(bundlePath);
+    },
+    route: routeData,
+    routeCache: __privateGet(this, _routeCache),
+    site: __privateGet(this, _manifest).site,
+    ssr: true,
+    method: info.routeData.type === "endpoint" ? "" : "GET",
+    headers: request.headers
+  });
+  if (result.type === "response") {
+    return result.response;
+  }
+  let html = result.html;
+  let bytes = __privateGet(this, _encoder).encode(html);
+  return new Response(bytes, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/html",
+      "Content-Length": bytes.byteLength.toString()
+    }
+  });
 };
-_loadModule = new WeakSet();
-loadModule_fn = async function(rootRelativePath) {
-  let modUrl = new URL(rootRelativePath, __privateGet(this, _rootFolder)).toString();
-  let mod;
-  try {
-    mod = await import(modUrl);
-    return mod;
-  } catch (err) {
-    throw new Error(`Unable to import ${modUrl}. Does this file exist?`);
+_callEndpoint = new WeakSet();
+callEndpoint_fn = async function(request, routeData, mod) {
+  const url = new URL(request.url);
+  const handler = mod;
+  const result = await callEndpoint(handler, {
+    headers: request.headers,
+    logging: defaultLogOptions,
+    method: request.method,
+    origin: url.origin,
+    pathname: url.pathname,
+    routeCache: __privateGet(this, _routeCache),
+    ssr: true
+  });
+  if (result.type === "response") {
+    return result.response;
+  } else {
+    const body = result.body;
+    const headers = new Headers();
+    const mimeType = mime.getType(url.pathname);
+    if (mimeType) {
+      headers.set("Content-Type", mimeType);
+    }
+    const bytes = __privateGet(this, _encoder).encode(body);
+    headers.set("Content-Length", bytes.byteLength.toString());
+    return new Response(bytes, {
+      status: 200,
+      headers
+    });
   }
 };
 export {
-  App
+  App,
+  deserializeManifest
 };

package/dist/core/app/node.js

@@ -26,9 +26,10 @@ async function loadManifest(rootFolder) {
 }
 async function loadApp(rootFolder) {
   const manifest = await loadManifest(rootFolder);
-  return new NodeApp(manifest, rootFolder);
+  return new NodeApp(manifest);
 }
 export {
+  NodeApp,
   loadApp,
   loadManifest
 };

package/dist/core/build/add-rollup-input.js

@@ -0,0 +1,50 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function fromEntries(entries) {
+  const obj = {};
+  for (const [k, v] of entries) {
+    obj[k] = v;
+  }
+  return obj;
+}
+function addRollupInput(inputOptions, newInputs) {
+  if (!inputOptions.input) {
+    return __spreadProps(__spreadValues({}, inputOptions), { input: newInputs });
+  }
+  if (typeof inputOptions.input === "string") {
+    return __spreadProps(__spreadValues({}, inputOptions), {
+      input: [inputOptions.input, ...newInputs]
+    });
+  }
+  if (Array.isArray(inputOptions.input)) {
+    return __spreadProps(__spreadValues({}, inputOptions), {
+      input: [...inputOptions.input, ...newInputs]
+    });
+  }
+  if (typeof inputOptions.input === "object") {
+    return __spreadProps(__spreadValues({}, inputOptions), {
+      input: __spreadValues(__spreadValues({}, inputOptions.input), fromEntries(newInputs.map((i) => [i.split("/").slice(-1)[0].split(".")[0], i])))
+    });
+  }
+  throw new Error(`Unknown rollup input type. Supported inputs are string, array and object.`);
+}
+export {
+  addRollupInput
+};

package/dist/core/build/common.js

@@ -0,0 +1,62 @@
+import npath from "path";
+import { appendForwardSlash } from "../../core/path.js";
+const STATUS_CODE_PAGES = /* @__PURE__ */ new Set(["/404", "/500"]);
+function getOutRoot(astroConfig) {
+  return new URL("./", astroConfig.dist);
+}
+function getServerRoot(astroConfig) {
+  const rootFolder = getOutRoot(astroConfig);
+  const serverFolder = new URL("./server/", rootFolder);
+  return serverFolder;
+}
+function getClientRoot(astroConfig) {
+  const rootFolder = getOutRoot(astroConfig);
+  const serverFolder = new URL("./client/", rootFolder);
+  return serverFolder;
+}
+function getOutFolder(astroConfig, pathname, routeType) {
+  const outRoot = getOutRoot(astroConfig);
+  switch (routeType) {
+    case "endpoint":
+      return new URL("." + appendForwardSlash(npath.dirname(pathname)), outRoot);
+    case "page":
+      switch (astroConfig.buildOptions.pageUrlFormat) {
+        case "directory": {
+          if (STATUS_CODE_PAGES.has(pathname)) {
+            return new URL("." + appendForwardSlash(npath.dirname(pathname)), outRoot);
+          }
+          return new URL("." + appendForwardSlash(pathname), outRoot);
+        }
+        case "file": {
+          return new URL("." + appendForwardSlash(npath.dirname(pathname)), outRoot);
+        }
+      }
+  }
+}
+function getOutFile(astroConfig, outFolder, pathname, routeType) {
+  switch (routeType) {
+    case "endpoint":
+      return new URL(npath.basename(pathname), outFolder);
+    case "page":
+      switch (astroConfig.buildOptions.pageUrlFormat) {
+        case "directory": {
+          if (STATUS_CODE_PAGES.has(pathname)) {
+            const baseName = npath.basename(pathname);
+            return new URL("./" + (baseName || "index") + ".html", outFolder);
+          }
+          return new URL("./index.html", outFolder);
+        }
+        case "file": {
+          const baseName = npath.basename(pathname);
+          return new URL("./" + (baseName || "index") + ".html", outFolder);
+        }
+      }
+  }
+}
+export {
+  getClientRoot,
+  getOutFile,
+  getOutFolder,
+  getOutRoot,
+  getServerRoot
+};

package/dist/core/build/generate.js

@@ -0,0 +1,174 @@
+import fs from "fs";
+import npath from "path";
+import { fileURLToPath } from "url";
+import { debug, error, info } from "../../core/logger.js";
+import { prependForwardSlash } from "../../core/path.js";
+import { BEFORE_HYDRATION_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
+import { call as callEndpoint } from "../endpoint/index.js";
+import { render } from "../render/core.js";
+import { createLinkStylesheetElementSet, createModuleScriptElementWithSrcSet } from "../render/ssr-element.js";
+import { getOutFile, getOutRoot, getOutFolder, getServerRoot } from "./common.js";
+import { getPageDataByComponent, eachPageData } from "./internal.js";
+import { bgMagenta, black, cyan, dim, magenta } from "kleur/colors";
+import { getTimeStat } from "./util.js";
+const MAX_CONCURRENT_RENDERS = 1;
+function* throttle(max, inPaths) {
+  let tmp = [];
+  let i = 0;
+  for (let path of inPaths) {
+    tmp.push(path);
+    if (i === max) {
+      yield tmp;
+      tmp.length = 0;
+      i = 0;
+    } else {
+      i++;
+    }
+  }
+  if (tmp.length) {
+    yield tmp;
+  }
+}
+function rootRelativeFacadeId(facadeId, astroConfig) {
+  return facadeId.slice(fileURLToPath(astroConfig.projectRoot).length);
+}
+function chunkIsPage(astroConfig, output, internals) {
+  if (output.type !== "chunk") {
+    return false;
+  }
+  const chunk = output;
+  if (chunk.facadeModuleId) {
+    const facadeToEntryId = prependForwardSlash(rootRelativeFacadeId(chunk.facadeModuleId, astroConfig));
+    return internals.entrySpecifierToBundleMap.has(facadeToEntryId);
+  }
+  return false;
+}
+async function generatePages(result, opts, internals, facadeIdToPageDataMap) {
+  var _a;
+  info(opts.logging, null, `
+${bgMagenta(black(" generating static routes "))}
+`);
+  const ssr = !!((_a = opts.astroConfig._ctx.adapter) == null ? void 0 : _a.serverEntrypoint);
+  const outFolder = ssr ? getServerRoot(opts.astroConfig) : getOutRoot(opts.astroConfig);
+  const ssrEntryURL = new URL(`./entry.mjs?time=${Date.now()}`, outFolder);
+  const ssrEntry = await import(ssrEntryURL.toString());
+  for (const pageData of eachPageData(internals)) {
+    await generatePage(opts, internals, pageData, ssrEntry);
+  }
+}
+async function generatePage(opts, internals, pageData, ssrEntry) {
+  let timeStart = performance.now();
+  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 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.`);
+  }
+  const generationOptions = {
+    pageData,
+    internals,
+    linkIds,
+    hoistedId,
+    mod: pageModule,
+    renderers
+  };
+  const icon = pageData.route.type === "page" ? cyan("</>") : magenta("{-}");
+  info(opts.logging, null, `${icon} ${pageData.route.component}`);
+  const renderPromises = [];
+  for (const paths of throttle(MAX_CONCURRENT_RENDERS, pageData.paths)) {
+    for (const path of paths) {
+      renderPromises.push(generatePath(path, opts, generationOptions));
+    }
+    await Promise.all(renderPromises);
+    const timeEnd = performance.now();
+    const timeChange = getTimeStat(timeStart, timeEnd);
+    let shouldLogTimeChange = !getTimeStat(timeStart, timeEnd).startsWith("0");
+    for (const path of paths) {
+      const timeIncrease = shouldLogTimeChange ? ` ${dim(`+${timeChange}`)}` : "";
+      info(opts.logging, null, `    ${dim("\u2503")} ${path}${timeIncrease}`);
+      shouldLogTimeChange = false;
+    }
+    timeStart = performance.now();
+    renderPromises.length = 0;
+  }
+}
+function addPageName(pathname, opts) {
+  opts.pageNames.push(pathname.replace(/\/?$/, "/").replace(/^\//, ""));
+}
+async function generatePath(pathname, opts, gopts) {
+  const { astroConfig, logging, origin, routeCache } = opts;
+  const { mod, internals, linkIds, hoistedId, pageData, renderers } = gopts;
+  if (pageData.route.type === "page") {
+    addPageName(pathname, opts);
+  }
+  debug("build", `Generating: ${pathname}`);
+  const site = astroConfig.buildOptions.site;
+  const links = createLinkStylesheetElementSet(linkIds.reverse(), site);
+  const scripts = createModuleScriptElementWithSrcSet(hoistedId ? [hoistedId] : [], site);
+  for (const script of astroConfig._ctx.scripts) {
+    if (script.stage === "head-inline") {
+      scripts.add({
+        props: {},
+        children: script.content
+      });
+    }
+  }
+  try {
+    const options = {
+      legacyBuild: false,
+      links,
+      logging,
+      markdownRender: astroConfig.markdownOptions.render,
+      mod,
+      origin,
+      pathname,
+      scripts,
+      renderers,
+      async resolve(specifier) {
+        const hashedFilePath = internals.entrySpecifierToBundleMap.get(specifier);
+        if (typeof hashedFilePath !== "string") {
+          if (specifier === BEFORE_HYDRATION_SCRIPT_ID) {
+            return "data:text/javascript;charset=utf-8,//[no before-hydration script]";
+          }
+          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;
+      },
+      method: "GET",
+      headers: new Headers(),
+      route: pageData.route,
+      routeCache,
+      site: astroConfig.buildOptions.site,
+      ssr: opts.astroConfig.buildOptions.experimentalSsr
+    };
+    let body;
+    if (pageData.route.type === "endpoint") {
+      const result = await callEndpoint(mod, options);
+      if (result.type === "response") {
+        throw new Error(`Returning a Response from an endpoint is not supported in SSG mode.`);
+      }
+      body = result.body;
+    } else {
+      const result = await render(options);
+      if (result.type !== "html") {
+        return;
+      }
+      body = result.html;
+    }
+    const outFolder = getOutFolder(astroConfig, pathname, pageData.route.type);
+    const outFile = getOutFile(astroConfig, outFolder, pathname, pageData.route.type);
+    await fs.promises.mkdir(outFolder, { recursive: true });
+    await fs.promises.writeFile(outFile, body, "utf-8");
+  } catch (err) {
+    error(opts.logging, "build", `Error rendering:`, err);
+  }
+}
+export {
+  chunkIsPage,
+  generatePages,
+  rootRelativeFacadeId
+};

package/dist/core/build/index.js

@@ -12,6 +12,7 @@ import { build as scanBasedBuild } from "./scan-based-build.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";
 async function build(config, options = { logging: defaultLogOptions }) {
   const builder = new AstroBuilder(config, options);
   await builder.build();
@@ -33,6 +34,7 @@ class AstroBuilder {
     this.manifest = createRouteManifest({ config }, this.logging);
   }
   async build() {
+    info(this.logging, "build", "Initial setup...");
     const { logging, origin } = this;
     const timer = {};
     timer.init = performance.now();
@@ -50,7 +52,9 @@ class AstroBuilder {
     const viteServer = await vite.createServer(viteConfig);
     this.viteServer = viteServer;
     debug("build", timerMessage("Vite started", timer.viteStart));
-    await runHookBuildStart({ config: this.config });
+    const buildConfig = { staticMode: void 0 };
+    await runHookBuildStart({ config: this.config, buildConfig });
+    info(this.logging, "build", "Collecting page data...");
     timer.loadStart = performance.now();
     const { assets, allPages } = await collectPagesData({
       astroConfig: this.config,
@@ -73,6 +77,7 @@ class AstroBuilder {
     debug("build", timerMessage("All pages loaded", timer.loadStart));
     const pageNames = [];
     timer.buildStart = performance.now();
+    info(this.logging, "build", colors.dim(`Completed in ${getTimeStat(timer.init, performance.now())}`));
     if (!this.config.buildOptions.legacyBuild) {
       await staticBuild({
         allPages,
@@ -82,7 +87,8 @@ class AstroBuilder {
         origin: this.origin,
         pageNames,
         routeCache: this.routeCache,
-        viteConfig: this.viteConfig
+        viteConfig: this.viteConfig,
+        buildConfig
       });
     } else {
       await scanBasedBuild({
@@ -96,7 +102,6 @@ class AstroBuilder {
         viteServer: this.viteServer
       });
     }
-    debug("build", timerMessage("Vite build finished", timer.buildStart));
     timer.assetsStart = performance.now();
     Object.keys(assets).map((k) => {
       if (!assets[k])
@@ -119,14 +124,22 @@ class AstroBuilder {
     await viteServer.close();
     await runHookBuildDone({ config: this.config, pages: pageNames });
     if (logging.level && levels[logging.level] <= levels["info"]) {
-      await this.printStats({ logging, timeStart: timer.init, pageCount: pageNames.length });
+      const buildMode = this.config.buildOptions.experimentalSsr ? "ssr" : "static";
+      await this.printStats({ logging, timeStart: timer.init, pageCount: pageNames.length, buildMode });
     }
   }
-  async printStats({ logging, timeStart, pageCount }) {
+  async printStats({ logging, timeStart, pageCount, buildMode }) {
     const buildTime = performance.now() - timeStart;
-    const total = buildTime < 750 ? `${Math.round(buildTime)}ms` : `${(buildTime / 1e3).toFixed(2)}s`;
-    const perPage = `${Math.round(buildTime / pageCount)}ms`;
-    info(logging, "build", `${pageCount} pages built in ${colors.bold(total)} ${colors.dim(`(${perPage}/page)`)}`);
+    const total = getTimeStat(timeStart, performance.now());
+    let messages = [];
+    if (buildMode === "static") {
+      const timePerPage = Math.round(buildTime / pageCount);
+      const perPageMsg = colors.dim(`(${colors.bold(`${timePerPage}ms`)} avg per page + resources)`);
+      messages = [`${pageCount} pages built in`, colors.bold(total), perPageMsg];
+    } else {
+      messages = ["Server built in", colors.bold(total)];
+    }
+    info(logging, "build", messages.join(" "));
     info(logging, "build", `\u{1F680} ${colors.cyan(colors.bold("Done"))}`);
   }
 }