astro 1.1.8 → 1.2.0

package/dist/@types/astro.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import type { MarkdownHeading, MarkdownMetadata, MarkdownRenderingResult, RehypePlugins, RemarkPlugins, RemarkRehype, ShikiConfig } from '@astrojs/markdown-remark';
 import type * as babel from '@babel/core';
 import type { AddressInfo } from 'net';
@@ -974,6 +975,7 @@ export interface APIContext {
 }
 export interface EndpointOutput {
     body: Body;
+    encoding?: BufferEncoding;
 }
 export declare type APIRoute = (context: APIContext) => EndpointOutput | Response | Promise<EndpointOutput | Response>;
 export interface EndpointHandler {

package/dist/cli/index.js

@@ -1,14 +1,17 @@
 import * as colors from "kleur/colors";
+import { pathToFileURL } from "url";
+import { normalizePath } from "vite";
 import yargs from "yargs-parser";
 import { z } from "zod";
 import add from "../core/add/index.js";
 import build from "../core/build/index.js";
-import { openConfig } from "../core/config.js";
+import { openConfig, resolveConfigPath, resolveFlags, resolveRoot } from "../core/config.js";
 import devServer from "../core/dev/index.js";
 import { collectErrorMetadata } from "../core/errors.js";
-import { debug, info, warn } from "../core/logger/core.js";
+import { debug, error, info } from "../core/logger/core.js";
 import { enableVerboseLogging, nodeLogDestination } from "../core/logger/node.js";
 import { formatConfigErrorMessage, formatErrorMessage, printHelp } from "../core/messages.js";
+import { appendForwardSlash } from "../core/path.js";
 import preview from "../core/preview/index.js";
 import { ASTRO_VERSION, createSafeError } from "../core/util.js";
 import * as event from "../events/index.js";
@@ -62,6 +65,18 @@ function resolveCommand(flags) {
   }
   return "help";
 }
+async function handleConfigError(e, { cwd, flags, logging }) {
+  const path = await resolveConfigPath({ cwd, flags });
+  if (e instanceof Error) {
+    if (path) {
+      error(logging, "astro", `Unable to load ${colors.bold(path)}
+`);
+    }
+    console.error(
+      formatErrorMessage(collectErrorMetadata(e, path ? pathToFileURL(path) : void 0)) + "\n"
+    );
+  }
+}
 async function runCommand(cmd, flags) {
   var _a;
   const root = flags.root;
@@ -98,39 +113,57 @@ async function runCommand(cmd, flags) {
       return await telemetryHandler.update(subcommand, { flags, telemetry });
     }
   }
-  let { astroConfig, userConfig, userConfigPath } = await openConfig({
+  let { astroConfig, userConfig } = await openConfig({
     cwd: root,
     flags,
     cmd,
     logging
+  }).catch(async (e) => {
+    await handleConfigError(e, { cwd: root, flags, logging });
+    return {};
   });
+  if (!astroConfig)
+    return;
   telemetry.record(event.eventCliSession(cmd, userConfig, flags));
   switch (cmd) {
     case "dev": {
-      async function startDevServer() {
-        const { watcher, stop } = await devServer(astroConfig, { logging, telemetry });
-        watcher.on("change", logRestartServerOnConfigChange);
-        watcher.on("unlink", logRestartServerOnConfigChange);
-        function logRestartServerOnConfigChange(changedFile) {
-          if (userConfigPath === changedFile) {
-            warn(logging, "astro", "Astro config updated. Restart server to see changes!");
-          }
-        }
-        watcher.on("add", async function restartServerOnNewConfigFile(addedFile) {
-          if (!userConfigPath && addedFile.includes("astro.config")) {
-            const addedConfig = await openConfig({ cwd: root, flags, cmd, logging });
-            if (addedConfig.userConfigPath) {
-              info(logging, "astro", "Astro config detected. Restarting server...");
-              astroConfig = addedConfig.astroConfig;
-              userConfig = addedConfig.userConfig;
-              userConfigPath = addedConfig.userConfigPath;
+      async function startDevServer({ isRestart = false } = {}) {
+        const { watcher, stop } = await devServer(astroConfig, { logging, telemetry, isRestart });
+        let restartInFlight = false;
+        const configFlag = resolveFlags(flags).config;
+        const configFlagPath = configFlag ? await resolveConfigPath({ cwd: root, flags }) : void 0;
+        const resolvedRoot = appendForwardSlash(resolveRoot(root));
+        const handleServerRestart = (logMsg) => async function(changedFile) {
+          if (!restartInFlight && (configFlag ? configFlagPath && normalizePath(configFlagPath) === normalizePath(changedFile) : new RegExp(
+            `${normalizePath(resolvedRoot)}.*astro.config.((mjs)|(cjs)|(js)|(ts))$`
+          ).test(normalizePath(changedFile)))) {
+            restartInFlight = true;
+            console.clear();
+            try {
+              const newConfig = await openConfig({
+                cwd: root,
+                flags,
+                cmd,
+                logging,
+                isConfigReload: true
+              });
+              info(logging, "astro", logMsg + "\n");
+              astroConfig = newConfig.astroConfig;
+              await stop();
+              await startDevServer({ isRestart: true });
+            } catch (e) {
+              await handleConfigError(e, { cwd: root, flags, logging });
               await stop();
-              await startDevServer();
+              info(logging, "astro", "Continuing with previous valid configuration\n");
+              await startDevServer({ isRestart: true });
             }
           }
-        });
+        };
+        watcher.on("change", handleServerRestart("Configuration updated. Restarting..."));
+        watcher.on("unlink", handleServerRestart("Configuration removed. Restarting..."));
+        watcher.on("add", handleServerRestart("Configuration added. Restarting..."));
       }
-      await startDevServer();
+      await startDevServer({ isRestart: false });
       return await new Promise(() => {
       });
     }

package/dist/core/add/index.js

@@ -8,7 +8,7 @@ import path from "path";
 import preferredPM from "preferred-pm";
 import prompts from "prompts";
 import { fileURLToPath, pathToFileURL } from "url";
-import { resolveConfigURL } from "../config.js";
+import { resolveConfigPath } from "../config.js";
 import { debug, info } from "../logger/core.js";
 import * as msg from "../messages.js";
 import { printHelp } from "../messages.js";
@@ -80,15 +80,73 @@ async function add(names, { cwd, flags, logging, telemetry }) {
     });
     return;
   }
-  let configURL;
+  const integrationNames = names.map((name) => ALIASES.has(name) ? ALIASES.get(name) : name);
+  const integrations = await validateIntegrations(integrationNames);
+  let installResult = await tryToInstallIntegrations({ integrations, cwd, flags, logging });
   const root = pathToFileURL(cwd ? path.resolve(cwd) : process.cwd());
-  configURL = await resolveConfigURL({ cwd, flags });
+  root.href = appendForwardSlash(root.href);
+  switch (installResult) {
+    case UpdateResult.updated: {
+      if (integrations.find((integration) => integration.id === "tailwind")) {
+        const possibleConfigFiles = [
+          "./tailwind.config.cjs",
+          "./tailwind.config.mjs",
+          "./tailwind.config.js"
+        ].map((p) => fileURLToPath(new URL(p, root)));
+        let alreadyConfigured = false;
+        for (const possibleConfigPath of possibleConfigFiles) {
+          if (existsSync(possibleConfigPath)) {
+            alreadyConfigured = true;
+            break;
+          }
+        }
+        if (!alreadyConfigured) {
+          info(
+            logging,
+            null,
+            `
+  ${magenta(
+              `Astro will generate a minimal ${bold("./tailwind.config.cjs")} file.`
+            )}
+`
+          );
+          if (await askToContinue({ flags })) {
+            await fs.writeFile(
+              fileURLToPath(new URL("./tailwind.config.cjs", root)),
+              TAILWIND_CONFIG_STUB,
+              { encoding: "utf-8" }
+            );
+            debug("add", `Generated default ./tailwind.config.cjs file`);
+          }
+        } else {
+          debug("add", `Using existing Tailwind configuration`);
+        }
+      }
+      break;
+    }
+    case UpdateResult.cancelled: {
+      info(
+        logging,
+        null,
+        msg.cancelled(
+          `Dependencies ${bold("NOT")} installed.`,
+          `Be sure to install them manually before continuing!`
+        )
+      );
+      break;
+    }
+    case UpdateResult.failure: {
+      throw createPrettyError(new Error(`Unable to install dependencies`));
+    }
+  }
+  const rawConfigPath = await resolveConfigPath({ cwd, flags });
+  let configURL = rawConfigPath ? pathToFileURL(rawConfigPath) : void 0;
   applyPolyfill();
   if (configURL) {
     debug("add", `Found config at ${configURL}`);
   } else {
     info(logging, "add", `Unable to locate a config file, generating one for you.`);
-    configURL = new URL("./astro.config.mjs", appendForwardSlash(root.href));
+    configURL = new URL("./astro.config.mjs", root);
     await fs.writeFile(fileURLToPath(configURL), ASTRO_CONFIG_STUB, { encoding: "utf-8" });
   }
   if (configURL == null ? void 0 : configURL.pathname.endsWith("package.json")) {
@@ -96,8 +154,6 @@ async function add(names, { cwd, flags, logging, telemetry }) {
       `Unable to use "astro add" with package.json configuration. Try migrating to \`astro.config.mjs\` and try again.`
     );
   }
-  const integrationNames = names.map((name) => ALIASES.has(name) ? ALIASES.get(name) : name);
-  const integrations = await validateIntegrations(integrationNames);
   let ast = null;
   try {
     ast = await parseAstroConfig(configURL);
@@ -139,7 +195,6 @@ async function add(names, { cwd, flags, logging, telemetry }) {
     throw createPrettyError(err);
   }
   let configResult;
-  let installResult;
   if (ast) {
     try {
       configResult = await updateAstroConfig({
@@ -173,72 +228,18 @@ async function add(names, { cwd, flags, logging, telemetry }) {
         }
       }
       info(logging, null, msg.success(`Configuration up-to-date.`));
-      break;
+      return;
     }
-  }
-  installResult = await tryToInstallIntegrations({ integrations, cwd, flags, logging });
-  switch (installResult) {
-    case UpdateResult.updated: {
-      const len = integrations.length;
-      if (integrations.find((integration) => integration.id === "tailwind")) {
-        const possibleConfigFiles = [
-          "./tailwind.config.cjs",
-          "./tailwind.config.mjs",
-          "./tailwind.config.js"
-        ].map((p) => fileURLToPath(new URL(p, configURL)));
-        let alreadyConfigured = false;
-        for (const possibleConfigPath of possibleConfigFiles) {
-          if (existsSync(possibleConfigPath)) {
-            alreadyConfigured = true;
-            break;
-          }
-        }
-        if (!alreadyConfigured) {
-          info(
-            logging,
-            null,
-            `
-  ${magenta(
-              `Astro will generate a minimal ${bold("./tailwind.config.cjs")} file.`
-            )}
-`
-          );
-          if (await askToContinue({ flags })) {
-            await fs.writeFile(
-              fileURLToPath(new URL("./tailwind.config.cjs", configURL)),
-              TAILWIND_CONFIG_STUB,
-              { encoding: "utf-8" }
-            );
-            debug("add", `Generated default ./tailwind.config.cjs file`);
-          }
-        } else {
-          debug("add", `Using existing Tailwind configuration`);
-        }
-      }
+    default: {
       const list = integrations.map((integration) => `  - ${integration.packageName}`).join("\n");
       info(
         logging,
         null,
         msg.success(
-          `Added the following integration${len === 1 ? "" : "s"} to your project:
+          `Added the following integration${integrations.length === 1 ? "" : "s"} to your project:
 ${list}`
         )
       );
-      return;
-    }
-    case UpdateResult.cancelled: {
-      info(
-        logging,
-        null,
-        msg.cancelled(
-          `Dependencies ${bold("NOT")} installed.`,
-          `Be sure to install them manually before continuing!`
-        )
-      );
-      return;
-    }
-    case UpdateResult.failure: {
-      throw createPrettyError(new Error(`Unable to install dependencies`));
     }
   }
 }

package/dist/core/build/generate.js

@@ -260,12 +260,14 @@ async function generatePath(pathname, opts, gopts) {
     streaming: true
   };
   let body;
+  let encoding;
   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;
+    encoding = result.encoding;
   } else {
     const response = await render(options);
     if (response.status !== 200 || !response.body) {
@@ -277,7 +279,7 @@ async function generatePath(pathname, opts, gopts) {
   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");
+  await fs.promises.writeFile(outFile, body, encoding ?? "utf-8");
 }
 export {
   chunkIsPage,

package/dist/core/build/vite-plugin-analyzer.js

@@ -55,7 +55,7 @@ function vitePluginAnalyzer(internals) {
   }
   return {
     name: "@astro/rollup-plugin-astro-analyzer",
-    generateBundle() {
+    async generateBundle() {
       var _a;
       const hoistScanner = hoistedScriptScanner();
       const ids = this.getModuleIds();
@@ -75,6 +75,12 @@ function vitePluginAnalyzer(internals) {
             const cid = c.resolvedPath ? decodeURI(c.resolvedPath) : c.specifier;
             internals.discoveredClientOnlyComponents.add(cid);
             clientOnlys.push(cid);
+            if (c.resolvedPath === c.specifier) {
+              const resolvedId = await this.resolve(c.specifier, id);
+              if (resolvedId) {
+                clientOnlys.push(resolvedId.id);
+              }
+            }
           }
           for (const [pageInfo] of getTopLevelPages(id, this)) {
             const pageData = getPageDataByViteID(internals, pageInfo.id);

package/dist/core/config.d.ts

@@ -235,22 +235,26 @@ export declare const AstroConfigSchema: z.ZodObject<{
 }>;
 /** Turn raw config values into normalized values */
 export declare function validateConfig(userConfig: any, root: string, cmd: string, logging: LogOptions): Promise<AstroConfig>;
+/** Convert the generic "yargs" flag object into our own, custom TypeScript object. */
+export declare function resolveFlags(flags: Partial<Flags>): CLIFlags;
+export declare function resolveRoot(cwd?: string): string;
 interface LoadConfigOptions {
     cwd?: string;
     flags?: Flags;
     cmd: string;
     validate?: boolean;
     logging: LogOptions;
+    /** Invalidate when reloading a previously loaded config */
+    isConfigReload?: boolean;
 }
 /**
  * Resolve the file URL of the user's `astro.config.js|cjs|mjs|ts` file
  * Note: currently the same as loadConfig but only returns the `filePath`
  * instead of the resolved config
  */
-export declare function resolveConfigURL(configOptions: Pick<LoadConfigOptions, 'cwd' | 'flags'>): Promise<URL | undefined>;
+export declare function resolveConfigPath(configOptions: Pick<LoadConfigOptions, 'cwd' | 'flags'>): Promise<string | undefined>;
 interface OpenConfigResult {
     userConfig: AstroUserConfig;
-    userConfigPath: string | undefined;
     astroConfig: AstroConfig;
     flags: CLIFlags;
     root: string;

package/dist/core/config.js

@@ -1,3 +1,4 @@
+import fs from "fs";
 import load, { ProloadError, resolve } from "@proload/core";
 import loadTypeScript from "@proload/plugin-tsm";
 import * as colors from "kleur/colors";
@@ -224,6 +225,9 @@ function resolveFlags(flags) {
     drafts: typeof flags.drafts === "boolean" ? flags.drafts : void 0
   };
 }
+function resolveRoot(cwd) {
+  return cwd ? path.resolve(cwd) : process.cwd();
+}
 function mergeCLIFlags(astroConfig, flags, cmd) {
   astroConfig.server = astroConfig.server || {};
   astroConfig.markdown = astroConfig.markdown || {};
@@ -239,38 +243,35 @@ function mergeCLIFlags(astroConfig, flags, cmd) {
   }
   return astroConfig;
 }
-async function resolveConfigURL(configOptions) {
-  const root = configOptions.cwd ? path.resolve(configOptions.cwd) : process.cwd();
+async function resolveConfigPath(configOptions) {
+  const root = resolveRoot(configOptions.cwd);
   const flags = resolveFlags(configOptions.flags || {});
   let userConfigPath;
   if (flags == null ? void 0 : flags.config) {
     userConfigPath = /^\.*\//.test(flags.config) ? flags.config : `./${flags.config}`;
     userConfigPath = fileURLToPath(new URL(userConfigPath, `file://${root}/`));
   }
-  const configPath = await resolve("astro", {
-    mustExist: false,
-    cwd: root,
-    filePath: userConfigPath
-  });
-  if (configPath) {
-    return pathToFileURL(configPath);
+  try {
+    const configPath = await resolve("astro", {
+      mustExist: !!userConfigPath,
+      cwd: root,
+      filePath: userConfigPath
+    });
+    return configPath;
+  } catch (e) {
+    if (e instanceof ProloadError && flags.config) {
+      throw new Error(`Unable to resolve --config "${flags.config}"! Does the file exist?`);
+    }
+    throw e;
   }
 }
 async function openConfig(configOptions) {
-  const root = configOptions.cwd ? path.resolve(configOptions.cwd) : process.cwd();
+  const root = resolveRoot(configOptions.cwd);
   const flags = resolveFlags(configOptions.flags || {});
   let userConfig = {};
-  let userConfigPath;
-  if (flags == null ? void 0 : flags.config) {
-    userConfigPath = /^\.*\//.test(flags.config) ? flags.config : `./${flags.config}`;
-    userConfigPath = fileURLToPath(
-      new URL(userConfigPath, appendForwardSlash(pathToFileURL(root).toString()))
-    );
-  }
-  const config = await tryLoadConfig(configOptions, flags, userConfigPath, root);
+  const config = await tryLoadConfig(configOptions, flags, root);
   if (config) {
     userConfig = config.value;
-    userConfigPath = config.filePath;
   }
   const astroConfig = await resolveConfig(
     userConfig,
@@ -282,56 +283,74 @@ async function openConfig(configOptions) {
   return {
     astroConfig,
     userConfig,
-    userConfigPath,
     flags,
     root
   };
 }
-async function tryLoadConfig(configOptions, flags, userConfigPath, root) {
+async function tryLoadConfig(configOptions, flags, root) {
+  let finallyCleanup = async () => {
+  };
   try {
+    let configPath = await resolveConfigPath({
+      cwd: configOptions.cwd,
+      flags: configOptions.flags
+    });
+    if (!configPath)
+      return void 0;
+    if (configOptions.isConfigReload) {
+      const tempConfigPath = path.join(
+        root,
+        `.temp.${Date.now()}.config${path.extname(configPath)}`
+      );
+      await fs.promises.writeFile(tempConfigPath, await fs.promises.readFile(configPath));
+      finallyCleanup = async () => {
+        try {
+          await fs.promises.unlink(tempConfigPath);
+        } catch {
+        }
+      };
+      configPath = tempConfigPath;
+    }
     const config = await load("astro", {
-      mustExist: !!userConfigPath,
+      mustExist: !!configPath,
       cwd: root,
-      filePath: userConfigPath
+      filePath: configPath
     });
     return config;
   } catch (e) {
     if (e instanceof ProloadError && flags.config) {
       throw new Error(`Unable to resolve --config "${flags.config}"! Does the file exist?`);
     }
-    const configURL = await resolveConfigURL(configOptions);
-    if (!configURL) {
+    const configPath = await resolveConfigPath(configOptions);
+    if (!configPath) {
       throw e;
     }
     const viteServer = await vite.createServer({
       server: { middlewareMode: true, hmr: false },
+      optimizeDeps: { entries: [] },
+      clearScreen: false,
       appType: "custom"
     });
     try {
-      const mod = await viteServer.ssrLoadModule(fileURLToPath(configURL));
+      const mod = await viteServer.ssrLoadModule(configPath);
       if (mod == null ? void 0 : mod.default) {
         return {
           value: mod.default,
-          filePath: fileURLToPath(configURL)
+          filePath: configPath
         };
       }
     } finally {
       await viteServer.close();
     }
+  } finally {
+    await finallyCleanup();
   }
 }
 async function loadConfig(configOptions) {
-  const root = configOptions.cwd ? path.resolve(configOptions.cwd) : process.cwd();
+  const root = resolveRoot(configOptions.cwd);
   const flags = resolveFlags(configOptions.flags || {});
   let userConfig = {};
-  let userConfigPath;
-  if (flags == null ? void 0 : flags.config) {
-    userConfigPath = /^\.*\//.test(flags.config) ? flags.config : `./${flags.config}`;
-    userConfigPath = fileURLToPath(
-      new URL(userConfigPath, appendForwardSlash(pathToFileURL(root).toString()))
-    );
-  }
-  const config = await tryLoadConfig(configOptions, flags, userConfigPath, root);
+  const config = await tryLoadConfig(configOptions, flags, root);
   if (config) {
     userConfig = config.value;
   }
@@ -380,6 +399,8 @@ export {
   mergeConfig,
   openConfig,
   resolveConfig,
-  resolveConfigURL,
+  resolveConfigPath,
+  resolveFlags,
+  resolveRoot,
   validateConfig
 };

package/dist/core/dev/index.d.ts

@@ -7,6 +7,7 @@ import { LogOptions } from '../logger/core.js';
 export interface DevOptions {
     logging: LogOptions;
     telemetry: AstroTelemetry;
+    isRestart?: boolean;
 }
 export interface DevServer {
     address: AddressInfo;

package/dist/core/dev/index.js

@@ -18,6 +18,7 @@ async function dev(config, options) {
   await options.telemetry.record([]);
   config = await runHookConfigSetup({ config, command: "dev", logging: options.logging });
   const { host, port } = config.server;
+  const { isRestart = false } = options;
   const rendererClientEntries = config._ctx.renderers.map((r) => r.clientEntrypoint).filter(Boolean);
   const viteConfig = await createVite(
     {
@@ -43,10 +44,11 @@ async function dev(config, options) {
       config,
       devServerAddressInfo,
       site,
-      https: !!((_a = viteConfig.server) == null ? void 0 : _a.https)
+      https: !!((_a = viteConfig.server) == null ? void 0 : _a.https),
+      isRestart
     })
   );
-  const currentVersion = "1.1.8";
+  const currentVersion = "1.2.0";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/endpoint/dev/index.d.ts

@@ -1,7 +1,9 @@
+/// <reference types="node" />
 import type { SSROptions } from '../../render/dev';
 export declare function call(ssrOpts: SSROptions): Promise<{
     type: "simple";
     body: string;
+    encoding?: BufferEncoding | undefined;
 } | {
     type: "response";
     response: Response;

package/dist/core/endpoint/index.d.ts

@@ -1,9 +1,11 @@
+/// <reference types="node" />
 import type { EndpointHandler } from '../../@types/astro';
 import type { RenderOptions } from '../render/core';
 export declare type EndpointOptions = Pick<RenderOptions, 'logging' | 'origin' | 'request' | 'route' | 'routeCache' | 'pathname' | 'route' | 'site' | 'ssr' | 'status'>;
 declare type EndpointCallResult = {
     type: 'simple';
     body: string;
+    encoding?: BufferEncoding;
 } | {
     type: 'response';
     response: Response;

package/dist/core/endpoint/index.js

@@ -17,7 +17,8 @@ async function call(mod, opts) {
   }
   return {
     type: "simple",
-    body: response.body
+    body: response.body,
+    encoding: response.encoding
   };
 }
 export {

package/dist/core/messages.d.ts

@@ -17,12 +17,13 @@ export declare function hmr({ file, style }: {
     style?: boolean;
 }): string;
 /** Display dev server host and startup time */
-export declare function devStart({ startupTime, devServerAddressInfo, config, https, site, }: {
+export declare function devStart({ startupTime, devServerAddressInfo, config, https, site, isRestart, }: {
     startupTime: number;
     devServerAddressInfo: AddressInfo;
     config: AstroConfig;
     https: boolean;
     site: URL | undefined;
+    isRestart?: boolean;
 }): string;
 export declare function telemetryNotice(): string;
 export declare function telemetryEnabled(): string;

package/dist/core/messages.js

@@ -44,9 +44,10 @@ function devStart({
   devServerAddressInfo,
   config,
   https,
-  site
+  site,
+  isRestart = false
 }) {
-  const version = "1.1.8";
+  const version = "1.2.0";
   const rootPath = site ? site.pathname : "/";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
@@ -77,7 +78,7 @@ function devStart({
   }
   const messages = [
     `${emoji("\u{1F680} ", "")}${bgGreen(black(` astro `))} ${green(`v${version}`)} ${dim(
-      `started in ${Math.round(startupTime)}ms`
+      `${isRestart ? "re" : ""}started in ${Math.round(startupTime)}ms`
     )}`,
     "",
     local,
@@ -225,7 +226,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"1.1.8"}`
+        `v${"1.2.0"}`
       )} ${headline}`
     );
   }

package/dist/core/util.js

@@ -5,7 +5,7 @@ import resolve from "resolve";
 import slash from "slash";
 import { fileURLToPath, pathToFileURL } from "url";
 import { prependForwardSlash, removeTrailingForwardSlash } from "./path.js";
-const ASTRO_VERSION = "1.1.8";
+const ASTRO_VERSION = "1.2.0";
 function isObject(value) {
   return typeof value === "object" && value != null;
 }

package/dist/runtime/server/astro-global.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "1.1.8";
+const ASTRO_VERSION = "1.2.0";
 function createDeprecatedFetchContentFn() {
   return () => {
     throw new Error("Deprecated: Astro.fetchContent() has been replaced with Astro.glob().");

package/dist/vite-plugin-astro/hmr.js

@@ -83,6 +83,8 @@ async function handleHotUpdate(ctx, { config, logging, compile }) {
   }
   const isSelfAccepting = mods.every((m) => m.isSelfAccepting || m.url.endsWith(".svelte"));
   if (isSelfAccepting) {
+    if (/astro\.config\.[cm][jt]s$/.test(file))
+      return mods;
     info(logging, "astro", msg.hmr({ file }));
   } else {
     info(logging, "astro", msg.reload({ file }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "1.1.8",
+  "version": "1.2.0",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -93,7 +93,7 @@
     "@babel/plugin-transform-react-jsx": "^7.17.12",
     "@babel/traverse": "^7.18.2",
     "@babel/types": "^7.18.4",
-    "@proload/core": "^0.3.2",
+    "@proload/core": "^0.3.3",
     "@proload/plugin-tsm": "^0.2.1",
     "@types/babel__core": "^7.1.19",
     "@types/html-escaper": "^3.0.0",