astro 6.1.3 → 6.1.4

package/dist/core/config/schemas/refined-validators.d.ts

@@ -0,0 +1,44 @@
+import type { AstroConfig } from '../../../types/public/config.js';
+export interface ConfigValidationIssue {
+    message: string;
+    path: (string | number)[];
+}
+type I18nConfig = NonNullable<AstroConfig['i18n']>;
+/**
+ * Validates that `build.assetsPrefix`, when specified as an object, includes a `fallback` key.
+ */
+export declare function validateAssetsPrefix(config: Pick<AstroConfig, 'build'>): ConfigValidationIssue[];
+/**
+ * Validates that remote pattern wildcards are only at the start of hostnames
+ * and at the end of pathnames.
+ */
+export declare function validateRemotePatterns(remotePatterns: AstroConfig['image']['remotePatterns']): ConfigValidationIssue[];
+/**
+ * Validates that `redirectToDefaultLocale` is not `true` when
+ * `prefixDefaultLocale` is `false`, which would cause infinite redirects.
+ */
+export declare function validateI18nRedirectToDefaultLocale(i18n: AstroConfig['i18n']): ConfigValidationIssue[];
+/**
+ * Validates that `outDir` is not inside `publicDir`, which would cause an infinite loop.
+ */
+export declare function validateOutDirNotInPublicDir(outDir: AstroConfig['outDir'], publicDir: AstroConfig['publicDir']): ConfigValidationIssue[];
+/**
+ * Validates that the default locale is present in the locales array.
+ */
+export declare function validateI18nDefaultLocale(i18n: Pick<I18nConfig, 'defaultLocale' | 'locales'>): ConfigValidationIssue[];
+/**
+ * Validates i18n fallback entries: keys and values must exist in locales,
+ * and the default locale cannot be used as a key.
+ */
+export declare function validateI18nFallback(i18n: Pick<I18nConfig, 'defaultLocale' | 'locales' | 'fallback'>): ConfigValidationIssue[];
+/**
+ * Validates i18n domain entries: locale keys must exist, domain values must be
+ * valid origin URLs, site must be set, and output must be 'server'.
+ */
+export declare function validateI18nDomains(config: Pick<AstroConfig, 'site' | 'output' | 'i18n'>): ConfigValidationIssue[];
+/**
+ * Validates that font `cssVariable` values start with `--` and don't contain
+ * spaces or colons.
+ */
+export declare function validateFontsCssVariables(fonts: NonNullable<AstroConfig['fonts']>): ConfigValidationIssue[];
+export {};

package/dist/core/config/schemas/refined-validators.js

@@ -0,0 +1,168 @@
+function validateAssetsPrefix(config) {
+  if (config.build.assetsPrefix && typeof config.build.assetsPrefix !== "string" && !config.build.assetsPrefix.fallback) {
+    return [
+      {
+        message: "The `fallback` is mandatory when defining the option as an object.",
+        path: ["build", "assetsPrefix"]
+      }
+    ];
+  }
+  return [];
+}
+function validateRemotePatterns(remotePatterns) {
+  const issues = [];
+  for (let i = 0; i < remotePatterns.length; i++) {
+    const { hostname, pathname } = remotePatterns[i];
+    if (hostname && hostname.includes("*") && !(hostname.startsWith("*.") || hostname.startsWith("**."))) {
+      issues.push({
+        message: "wildcards can only be placed at the beginning of the hostname",
+        path: ["image", "remotePatterns", i, "hostname"]
+      });
+    }
+    if (pathname && pathname.includes("*") && !(pathname.endsWith("/*") || pathname.endsWith("/**"))) {
+      issues.push({
+        message: "wildcards can only be placed at the end of a pathname",
+        path: ["image", "remotePatterns", i, "pathname"]
+      });
+    }
+  }
+  return issues;
+}
+function validateI18nRedirectToDefaultLocale(i18n) {
+  if (i18n && typeof i18n.routing !== "string" && i18n.routing.prefixDefaultLocale === false && i18n.routing.redirectToDefaultLocale === true) {
+    return [
+      {
+        message: "The option `i18n.routing.redirectToDefaultLocale` can be used only when `i18n.routing.prefixDefaultLocale` is set to `true`; otherwise, redirects might cause infinite loops. Remove the option `i18n.routing.redirectToDefaultLocale`, or change its value to `false`.",
+        path: ["i18n", "routing", "redirectToDefaultLocale"]
+      }
+    ];
+  }
+  return [];
+}
+function validateOutDirNotInPublicDir(outDir, publicDir) {
+  if (outDir.toString().startsWith(publicDir.toString())) {
+    return [
+      {
+        message: "The value of `outDir` must not point to a path within the folder set as `publicDir`, this will cause an infinite loop",
+        path: ["outDir"]
+      }
+    ];
+  }
+  return [];
+}
+function validateI18nDefaultLocale(i18n) {
+  const locales = i18n.locales.map((locale) => typeof locale === "string" ? locale : locale.path);
+  if (!locales.includes(i18n.defaultLocale)) {
+    return [
+      {
+        message: `The default locale \`${i18n.defaultLocale}\` is not present in the \`i18n.locales\` array.`,
+        path: ["i18n", "locales"]
+      }
+    ];
+  }
+  return [];
+}
+function validateI18nFallback(i18n) {
+  const issues = [];
+  const { defaultLocale, fallback } = i18n;
+  if (!fallback) return [];
+  const locales = i18n.locales.map((locale) => typeof locale === "string" ? locale : locale.path);
+  for (const [fallbackFrom, fallbackTo] of Object.entries(fallback)) {
+    if (!locales.includes(fallbackFrom)) {
+      issues.push({
+        message: `The locale \`${fallbackFrom}\` key in the \`i18n.fallback\` record doesn't exist in the \`i18n.locales\` array.`,
+        path: ["i18n", "fallbacks"]
+      });
+    }
+    if (fallbackFrom === defaultLocale) {
+      issues.push({
+        message: `You can't use the default locale as a key. The default locale can only be used as value.`,
+        path: ["i18n", "fallbacks"]
+      });
+    }
+    if (!locales.includes(fallbackTo)) {
+      issues.push({
+        message: `The locale \`${fallbackTo}\` value in the \`i18n.fallback\` record doesn't exist in the \`i18n.locales\` array.`,
+        path: ["i18n", "fallbacks"]
+      });
+    }
+  }
+  return issues;
+}
+function validateI18nDomains(config) {
+  const issues = [];
+  const i18n = config.i18n;
+  if (!i18n?.domains) return [];
+  const entries = Object.entries(i18n.domains);
+  const hasDomains = Object.keys(i18n.domains).length > 0;
+  if (entries.length > 0 && !hasDomains) {
+    issues.push({
+      message: `When specifying some domains, the property \`i18n.routing.strategy\` must be set to \`"domains"\`.`,
+      path: ["i18n", "routing", "strategy"]
+    });
+  }
+  if (hasDomains) {
+    if (!config.site) {
+      issues.push({
+        message: "The option `site` isn't set. When using the 'domains' strategy for `i18n`, `site` is required to create absolute URLs for locales that aren't mapped to a domain.",
+        path: ["site"]
+      });
+    }
+    if (config.output !== "server") {
+      issues.push({
+        message: 'Domain support is only available when `output` is `"server"`.',
+        path: ["output"]
+      });
+    }
+  }
+  const locales = i18n.locales.map((locale) => typeof locale === "string" ? locale : locale.path);
+  for (const [domainKey, domainValue] of entries) {
+    if (!locales.includes(domainKey)) {
+      issues.push({
+        message: `The locale \`${domainKey}\` key in the \`i18n.domains\` record doesn't exist in the \`i18n.locales\` array.`,
+        path: ["i18n", "domains"]
+      });
+    }
+    if (!domainValue.startsWith("https") && !domainValue.startsWith("http")) {
+      issues.push({
+        message: "The domain value must be a valid URL, and it has to start with 'https' or 'http'.",
+        path: ["i18n", "domains"]
+      });
+    } else {
+      try {
+        const domainUrl = new URL(domainValue);
+        if (domainUrl.pathname !== "/") {
+          issues.push({
+            message: `The URL \`${domainValue}\` must contain only the origin. A subsequent pathname isn't allowed here. Remove \`${domainUrl.pathname}\`.`,
+            path: ["i18n", "domains"]
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return issues;
+}
+function validateFontsCssVariables(fonts) {
+  const issues = [];
+  for (let i = 0; i < fonts.length; i++) {
+    const { cssVariable } = fonts[i];
+    if (!cssVariable.startsWith("--") || cssVariable.includes(" ") || cssVariable.includes(":")) {
+      issues.push({
+        message: `**cssVariable** property "${cssVariable}" contains invalid characters for CSS variable generation. It must start with -- and be a valid indent: https://developer.mozilla.org/en-US/docs/Web/CSS/ident.`,
+        path: ["fonts", i, "cssVariable"]
+      });
+    }
+  }
+  return issues;
+}
+export {
+  validateAssetsPrefix,
+  validateFontsCssVariables,
+  validateI18nDefaultLocale,
+  validateI18nDomains,
+  validateI18nFallback,
+  validateI18nRedirectToDefaultLocale,
+  validateOutDirNotInPublicDir,
+  validateRemotePatterns
+};

package/dist/core/config/schemas/refined.js

@@ -1,152 +1,39 @@
 import * as z from "zod/v4";
+import {
+  validateAssetsPrefix,
+  validateFontsCssVariables,
+  validateI18nDefaultLocale,
+  validateI18nDomains,
+  validateI18nFallback,
+  validateI18nRedirectToDefaultLocale,
+  validateOutDirNotInPublicDir,
+  validateRemotePatterns
+} from "./refined-validators.js";
 const AstroConfigRefinedSchema = z.custom().superRefine((config, ctx) => {
-  if (config.build.assetsPrefix && typeof config.build.assetsPrefix !== "string" && !config.build.assetsPrefix.fallback) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "The `fallback` is mandatory when defining the option as an object.",
-      path: ["build", "assetsPrefix"]
-    });
-  }
-  for (let i = 0; i < config.image.remotePatterns.length; i++) {
-    const { hostname, pathname } = config.image.remotePatterns[i];
-    if (hostname && hostname.includes("*") && !(hostname.startsWith("*.") || hostname.startsWith("**."))) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "wildcards can only be placed at the beginning of the hostname",
-        path: ["image", "remotePatterns", i, "hostname"]
-      });
-    }
-    if (pathname && pathname.includes("*") && !(pathname.endsWith("/*") || pathname.endsWith("/**"))) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "wildcards can only be placed at the end of a pathname",
-        path: ["image", "remotePatterns", i, "pathname"]
-      });
-    }
+  let issues = [];
+  issues = issues.concat(
+    validateAssetsPrefix(config),
+    validateRemotePatterns(config.image.remotePatterns),
+    validateI18nRedirectToDefaultLocale(config.i18n),
+    validateOutDirNotInPublicDir(config.outDir, config.publicDir)
+  );
+  if (config.i18n) {
+    issues = issues.concat(
+      validateI18nDefaultLocale(config.i18n),
+      validateI18nFallback(config.i18n),
+      validateI18nDomains(config)
+    );
   }
-  if (config.i18n && typeof config.i18n.routing !== "string" && config.i18n.routing.prefixDefaultLocale === false && config.i18n.routing.redirectToDefaultLocale === true) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "The option `i18n.routing.redirectToDefaultLocale` can be used only when `i18n.routing.prefixDefaultLocale` is set to `true`; otherwise, redirects might cause infinite loops. Remove the option `i18n.routing.redirectToDefaultLocale`, or change its value to `false`.",
-      path: ["i18n", "routing", "redirectToDefaultLocale"]
-    });
+  if (config.fonts && config.fonts.length > 0) {
+    issues = issues.concat(validateFontsCssVariables(config.fonts));
   }
-  if (config.outDir.toString().startsWith(config.publicDir.toString())) {
+  for (const issue of issues) {
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
-      message: "The value of `outDir` must not point to a path within the folder set as `publicDir`, this will cause an infinite loop",
-      path: ["outDir"]
+      message: issue.message,
+      path: issue.path
     });
   }
-  if (config.i18n) {
-    const { defaultLocale, locales: _locales, fallback, domains } = config.i18n;
-    const locales = _locales.map((locale) => {
-      if (typeof locale === "string") {
-        return locale;
-      } else {
-        return locale.path;
-      }
-    });
-    if (!locales.includes(defaultLocale)) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: `The default locale \`${defaultLocale}\` is not present in the \`i18n.locales\` array.`,
-        path: ["i18n", "locales"]
-      });
-    }
-    if (fallback) {
-      for (const [fallbackFrom, fallbackTo] of Object.entries(fallback)) {
-        if (!locales.includes(fallbackFrom)) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `The locale \`${fallbackFrom}\` key in the \`i18n.fallback\` record doesn't exist in the \`i18n.locales\` array.`,
-            path: ["i18n", "fallbacks"]
-          });
-        }
-        if (fallbackFrom === defaultLocale) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `You can't use the default locale as a key. The default locale can only be used as value.`,
-            path: ["i18n", "fallbacks"]
-          });
-        }
-        if (!locales.includes(fallbackTo)) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `The locale \`${fallbackTo}\` value in the \`i18n.fallback\` record doesn't exist in the \`i18n.locales\` array.`,
-            path: ["i18n", "fallbacks"]
-          });
-        }
-      }
-    }
-    if (domains) {
-      const entries = Object.entries(domains);
-      const hasDomains = domains ? Object.keys(domains).length > 0 : false;
-      if (entries.length > 0 && !hasDomains) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: `When specifying some domains, the property \`i18n.routing.strategy\` must be set to \`"domains"\`.`,
-          path: ["i18n", "routing", "strategy"]
-        });
-      }
-      if (hasDomains) {
-        if (!config.site) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "The option `site` isn't set. When using the 'domains' strategy for `i18n`, `site` is required to create absolute URLs for locales that aren't mapped to a domain.",
-            path: ["site"]
-          });
-        }
-        if (config.output !== "server") {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: 'Domain support is only available when `output` is `"server"`.',
-            path: ["output"]
-          });
-        }
-      }
-      for (const [domainKey, domainValue] of entries) {
-        if (!locales.includes(domainKey)) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `The locale \`${domainKey}\` key in the \`i18n.domains\` record doesn't exist in the \`i18n.locales\` array.`,
-            path: ["i18n", "domains"]
-          });
-        }
-        if (!domainValue.startsWith("https") && !domainValue.startsWith("http")) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "The domain value must be a valid URL, and it has to start with 'https' or 'http'.",
-            path: ["i18n", "domains"]
-          });
-        } else {
-          try {
-            const domainUrl = new URL(domainValue);
-            if (domainUrl.pathname !== "/") {
-              ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `The URL \`${domainValue}\` must contain only the origin. A subsequent pathname isn't allowed here. Remove \`${domainUrl.pathname}\`.`,
-                path: ["i18n", "domains"]
-              });
-            }
-          } catch {
-          }
-        }
-      }
-    }
-  }
-  if (config.fonts && config.fonts.length > 0) {
-    for (let i = 0; i < config.fonts.length; i++) {
-      const { cssVariable } = config.fonts[i];
-      if (!cssVariable.startsWith("--") || cssVariable.includes(" ") || cssVariable.includes(":")) {
-        ctx.addIssue({
-          code: "custom",
-          message: `**cssVariable** property "${cssVariable}" contains invalid characters for CSS variable generation. It must start with -- and be a valid indent: https://developer.mozilla.org/en-US/docs/Web/CSS/ident.`,
-          path: ["fonts", i, "cssVariable"]
-        });
-      }
-    }
-  }
 });
 export {
   AstroConfigRefinedSchema

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "6.1.3";
+const ASTRO_VERSION = "6.1.4";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";

package/dist/core/cookies/cookies.js

@@ -5,6 +5,7 @@ const DELETED_VALUE = "deleted";
 const responseSentSymbol = /* @__PURE__ */ Symbol.for("astro.responseSent");
 const identity = (value) => value;
 class AstroCookie {
+  value;
   constructor(value) {
     this.value = value;
   }

package/dist/core/dev/dev.js

@@ -37,7 +37,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "6.1.3";
+  const currentVersion = "6.1.4";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/dev/restart.js

@@ -3,26 +3,18 @@ import * as vite from "vite";
 import { globalContentLayer } from "../../content/instance.js";
 import { attachContentServerListeners } from "../../content/server-listeners.js";
 import { eventCliSession, telemetry } from "../../events/index.js";
+import { runHookConfigDone, runHookConfigSetup } from "../../integrations/hooks.js";
 import { SETTINGS_FILE } from "../../preferences/constants.js";
+import { getPrerenderDefault } from "../../prerender/utils.js";
 import { createSettings, resolveConfig } from "../config/index.js";
-import { createNodeLogger } from "../logger/node.js";
+import { createVite } from "../create-vite.js";
 import { collectErrorMetadata } from "../errors/dev/utils.js";
 import { isAstroConfigZodError } from "../errors/errors.js";
 import { createSafeError } from "../errors/index.js";
+import { createNodeLogger } from "../logger/node.js";
 import { formatErrorMessage, warnIfCspWithShiki } from "../messages/runtime.js";
-import { createContainer, startContainer } from "./container.js";
-async function createRestartedContainer(container, settings) {
-  const { logger, fs, inlineConfig } = container;
-  const newContainer = await createContainer({
-    isRestart: true,
-    logger,
-    settings,
-    inlineConfig,
-    fs
-  });
-  await startContainer(newContainer);
-  return newContainer;
-}
+import { createRoutesList } from "../routing/create-manifest.js";
+import { createContainer } from "./container.js";
 const configRE = /.*astro.config.(?:mjs|mts|cjs|cts|js|ts)$/;
 function shouldRestartContainer({ settings, inlineConfig, restartInFlight }, changedFile) {
   if (restartInFlight) return false;
@@ -47,25 +39,41 @@ function shouldRestartContainer({ settings, inlineConfig, restartInFlight }, cha
   }
   return shouldRestart;
 }
-async function restartContainer(container) {
-  const { logger, close, settings: existingSettings } = container;
+async function restartContainerInPlace(container) {
+  const { logger, settings: existingSettings, inlineConfig, fs } = container;
   container.restartInFlight = true;
   try {
-    const { astroConfig } = await resolveConfig(container.inlineConfig, "dev", container.fs);
-    if (astroConfig.security.csp) {
-      logger.warn(
-        "config",
-        "Astro's Content Security Policy (CSP) does not work in development mode. To verify your CSP implementation, build the project and run the preview server."
-      );
-    }
+    const { astroConfig } = await resolveConfig(inlineConfig, "dev", fs);
     warnIfCspWithShiki(astroConfig, logger);
-    const settings = await createSettings(
+    let settings = await createSettings(
       astroConfig,
-      container.inlineConfig.logLevel,
+      inlineConfig.logLevel,
       fileURLToPath(existingSettings.config.root)
     );
-    await close();
-    return await createRestartedContainer(container, settings);
+    settings = await runHookConfigSetup({ settings, command: "dev", logger, isRestart: true });
+    if (!settings.adapter?.adapterFeatures?.buildOutput) {
+      settings.buildOutput = getPrerenderDefault(settings.config) ? "static" : "server";
+    }
+    await runHookConfigDone({ settings, logger, command: "dev" });
+    const mode = inlineConfig?.mode ?? "development";
+    const {
+      server: { host, headers, allowedHosts }
+    } = settings.config;
+    const rendererClientEntries = settings.renderers.map((r) => r.clientEntrypoint).filter(Boolean);
+    const routesList = await createRoutesList({ settings, fsMod: fs }, logger, { dev: true });
+    const address = container.viteServer.httpServer?.address();
+    const port = address !== null && typeof address === "object" ? address.port : void 0;
+    const newViteConfig = await createVite(
+      {
+        server: { host, headers, allowedHosts, port },
+        optimizeDeps: { include: rendererClientEntries }
+      },
+      { settings, logger, mode, command: "dev", fs, sync: false, routesList }
+    );
+    container.viteServer.config = await vite.resolveConfig(newViteConfig, "serve");
+    await container.viteServer.restart();
+    container.settings = settings;
+    return settings;
   } catch (_err) {
     const error = createSafeError(_err);
     if (!isAstroConfigZodError(_err)) {
@@ -74,16 +82,14 @@ async function restartContainer(container) {
         formatErrorMessage(collectErrorMetadata(error), logger.level() === "debug") + "\n"
       );
     }
-    container.viteServer.environments.client.hot.send({
+    container.viteServer.environments?.client?.hot?.send({
       type: "error",
-      err: {
-        message: error.message,
-        stack: error.stack || ""
-      }
+      err: { message: error.message, stack: error.stack || "" }
     });
-    container.restartInFlight = false;
     logger.error(null, "Continuing with previous valid configuration\n");
     return error;
+  } finally {
+    container.restartInFlight = false;
   }
 }
 async function createContainerWithAutomaticRestart({
@@ -92,12 +98,6 @@ async function createContainerWithAutomaticRestart({
 }) {
   const logger = createNodeLogger(inlineConfig ?? {});
   const { userConfig, astroConfig } = await resolveConfig(inlineConfig ?? {}, "dev", fs);
-  if (astroConfig.security.csp) {
-    logger.warn(
-      "config",
-      "Astro's Content Security Policy (CSP) does not work in development mode. To verify your CSP implementation, build the project and run the preview server."
-    );
-  }
   warnIfCspWithShiki(astroConfig, logger);
   telemetry.record(eventCliSession("dev", userConfig));
   const settings = await createSettings(
@@ -119,7 +119,6 @@ async function createContainerWithAutomaticRestart({
     container: initialContainer,
     bindCLIShortcuts() {
       const customShortcuts = [
-        // Disable default Vite shortcuts that don't work well with Astro
         { key: "r", description: "" },
         { key: "u", description: "" },
         { key: "c", description: "" }
@@ -139,42 +138,38 @@ async function createContainerWithAutomaticRestart({
       return restartComplete;
     }
   };
-  async function handleServerRestart(logMsg = "", server) {
-    logger.info(null, (logMsg + " Restarting...").trim());
-    const container = restart.container;
-    const result = await restartContainer(container);
-    if (result instanceof Error) {
-      resolveRestart(result);
-    } else {
-      restart.container = result;
-      setupContainer();
-      await attachContentServerListeners(restart.container);
-      if (server) {
-        server.resolvedUrls = result.viteServer.resolvedUrls;
-      }
-      resolveRestart(null);
-    }
-    restartComplete = new Promise((resolve) => {
-      resolveRestart = resolve;
-    });
-  }
   function handleChangeRestart(logMsg) {
     return async function(changedFile) {
       if (shouldRestartContainer(restart.container, changedFile)) {
-        handleServerRestart(logMsg);
+        logger.info(null, (logMsg + " Restarting...").trim());
+        const result = await restartContainerInPlace(restart.container);
+        if (result instanceof Error) {
+          resolveRestart(result);
+        } else {
+          setupContainer();
+          await attachContentServerListeners(restart.container);
+          resolveRestart(null);
+        }
+        restartComplete = new Promise((resolve) => {
+          resolveRestart = resolve;
+        });
       }
     };
   }
+  let changeHandler;
+  let unlinkHandler;
+  let addHandler;
   function setupContainer() {
     const watcher = restart.container.viteServer.watcher;
-    watcher.on("change", handleChangeRestart("Configuration file updated."));
-    watcher.on("unlink", handleChangeRestart("Configuration file removed."));
-    watcher.on("add", handleChangeRestart("Configuration file added."));
-    restart.container.viteServer.restart = async () => {
-      if (!restart.container.restartInFlight) {
-        await handleServerRestart("", restart.container.viteServer);
-      }
-    };
+    if (changeHandler) watcher.off("change", changeHandler);
+    if (unlinkHandler) watcher.off("unlink", unlinkHandler);
+    if (addHandler) watcher.off("add", addHandler);
+    changeHandler = handleChangeRestart("Configuration file updated.");
+    unlinkHandler = handleChangeRestart("Configuration file removed.");
+    addHandler = handleChangeRestart("Configuration file added.");
+    watcher.on("change", changeHandler);
+    watcher.on("unlink", unlinkHandler);
+    watcher.on("add", addHandler);
   }
   setupContainer();
   return restart;

package/dist/core/messages/runtime.js

@@ -276,7 +276,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"6.1.3"}`
+        `v${"6.1.4"}`
       )} ${headline}`
     );
   }

package/dist/core/render-context.d.ts

@@ -1,6 +1,6 @@
 import type { ActionAPIContext } from '../actions/runtime/types.js';
 import type { ComponentInstance } from '../types/astro.js';
-import type { MiddlewareHandler, Props } from '../types/public/common.js';
+import type { MiddlewareHandler, Params, Props } from '../types/public/common.js';
 import type { APIContext, AstroGlobal } from '../types/public/context.js';
 import type { RouteData, SSRResult } from '../types/public/internal.js';
 import type { ServerIslandMappings, SSRActions } from './app/types.js';
@@ -26,7 +26,7 @@ export declare class RenderContext {
     status: number;
     clientAddress: string | undefined;
     protected cookies: AstroCookies;
-    params: import("../types/public/common.js").Params;
+    params: Params;
     protected url: URL;
     props: Props;
     partial: undefined | boolean;

package/dist/core/render-context.js

@@ -38,6 +38,26 @@ import { AstroSession } from "./session/runtime.js";
 import { collapseDuplicateSlashes } from "@astrojs/internal-helpers/path";
 import { validateAndDecodePathname } from "./util/pathname.js";
 class RenderContext {
+  pipeline;
+  locals;
+  middleware;
+  actions;
+  serverIslands;
+  // It must be a DECODED pathname
+  pathname;
+  request;
+  routeData;
+  status;
+  clientAddress;
+  cookies;
+  params;
+  url;
+  props;
+  partial;
+  shouldInjectCspMetaTags;
+  session;
+  cache;
+  skipMiddleware;
   constructor(pipeline, locals, middleware, actions, serverIslands, pathname, request, routeData, status, clientAddress, cookies = new AstroCookies(request), params = getParams(routeData, pathname), url = RenderContext.#createNormalizedUrl(request.url), props = {}, partial = void 0, shouldInjectCspMetaTags = pipeline.manifest.shouldInjectCspMetaTags, session = void 0, cache, skipMiddleware = false) {
     this.pipeline = pipeline;
     this.locals = locals;