full site update

node_modules/astro/dist/integrations/features-validation.d.ts

@@ -1,7 +1,15 @@
-import type { AstroAdapterFeatures, AstroConfig, AstroFeatureMap } from '../@types/astro.js';
 import type { Logger } from '../core/logger/core.js';
+import type { AstroSettings } from '../types/astro.js';
+import type { AstroAdapterFeatureMap } from '../types/public/integrations.js';
+export declare const AdapterFeatureStability: {
+    readonly STABLE: "stable";
+    readonly DEPRECATED: "deprecated";
+    readonly UNSUPPORTED: "unsupported";
+    readonly EXPERIMENTAL: "experimental";
+    readonly LIMITED: "limited";
+};
 type ValidationResult = {
-    [Property in keyof AstroFeatureMap]: boolean;
+    [Property in keyof AstroAdapterFeatureMap]: boolean;
 };
 /**
  * Checks whether an adapter supports certain features that are enabled via Astro configuration.
@@ -10,5 +18,6 @@ type ValidationResult = {
  * will throw a runtime error.
  *
  */
-export declare function validateSupportedFeatures(adapterName: string, featureMap: AstroFeatureMap, config: AstroConfig, adapterFeatures: AstroAdapterFeatures | undefined, logger: Logger): ValidationResult;
+export declare function validateSupportedFeatures(adapterName: string, featureMap: AstroAdapterFeatureMap, settings: AstroSettings, logger: Logger): ValidationResult;
+export declare function getAdapterStaticRecommendation(adapterName: string): string | undefined;
 export {};

node_modules/astro/dist/integrations/features-validation.js

@@ -1,20 +1,18 @@
-const STABLE = "stable";
-const DEPRECATED = "deprecated";
-const UNSUPPORTED = "unsupported";
-const EXPERIMENTAL = "experimental";
-const UNSUPPORTED_ASSETS_FEATURE = {
-  supportKind: UNSUPPORTED,
-  isSquooshCompatible: false,
-  isSharpCompatible: false
+const AdapterFeatureStability = {
+  STABLE: "stable",
+  DEPRECATED: "deprecated",
+  UNSUPPORTED: "unsupported",
+  EXPERIMENTAL: "experimental",
+  LIMITED: "limited"
 };
-function validateSupportedFeatures(adapterName, featureMap, config, adapterFeatures, logger) {
+function validateSupportedFeatures(adapterName, featureMap, settings, logger) {
   const {
-    assets = UNSUPPORTED_ASSETS_FEATURE,
-    serverOutput = UNSUPPORTED,
-    staticOutput = UNSUPPORTED,
-    hybridOutput = UNSUPPORTED,
-    i18nDomains = UNSUPPORTED,
-    envGetSecret = UNSUPPORTED
+    serverOutput = AdapterFeatureStability.UNSUPPORTED,
+    staticOutput = AdapterFeatureStability.UNSUPPORTED,
+    hybridOutput = AdapterFeatureStability.UNSUPPORTED,
+    i18nDomains = AdapterFeatureStability.UNSUPPORTED,
+    envGetSecret = AdapterFeatureStability.UNSUPPORTED,
+    sharpImageService = AdapterFeatureStability.UNSUPPORTED
   } = featureMap;
   const validationResult = {};
   validationResult.staticOutput = validateSupportKind(
@@ -22,108 +20,117 @@ function validateSupportedFeatures(adapterName, featureMap, config, adapterFeatu
     adapterName,
     logger,
     "staticOutput",
-    () => config?.output === "static"
+    () => settings.buildOutput === "static"
   );
   validationResult.hybridOutput = validateSupportKind(
     hybridOutput,
     adapterName,
     logger,
     "hybridOutput",
-    () => config?.output === "hybrid"
+    () => settings.config.output == "static" && settings.buildOutput === "server"
   );
   validationResult.serverOutput = validateSupportKind(
     serverOutput,
     adapterName,
     logger,
     "serverOutput",
-    () => config?.output === "server"
+    () => settings.config?.output === "server" || settings.buildOutput === "server"
   );
-  validationResult.assets = validateAssetsFeature(assets, adapterName, config, logger);
-  if (config.i18n?.domains) {
+  if (settings.config.i18n?.domains) {
     validationResult.i18nDomains = validateSupportKind(
       i18nDomains,
       adapterName,
       logger,
       "i18nDomains",
       () => {
-        return config?.output === "server" && !config?.site;
+        return settings.config?.output === "server" && !settings.config?.site;
       }
     );
-    if (adapterFeatures?.functionPerRoute) {
-      logger.error(
-        "config",
-        "The Astro feature `i18nDomains` is incompatible with the Adapter feature `functionPerRoute`"
-      );
-    }
-  }
-  if (config.experimental?.env) {
-    validationResult.envGetSecret = validateSupportKind(
-      envGetSecret,
-      adapterName,
-      logger,
-      "astro:env getSecret",
-      () => true
-    );
   }
+  validationResult.envGetSecret = validateSupportKind(
+    envGetSecret,
+    adapterName,
+    logger,
+    "astro:env getSecret",
+    () => Object.keys(settings.config?.env?.schema ?? {}).length !== 0
+  );
+  validationResult.sharpImageService = validateSupportKind(
+    sharpImageService,
+    adapterName,
+    logger,
+    "sharp",
+    () => settings.config?.image?.service?.entrypoint === "astro/assets/services/sharp"
+  );
   return validationResult;
 }
+function unwrapSupportKind(supportKind) {
+  if (!supportKind) {
+    return void 0;
+  }
+  return typeof supportKind === "object" ? supportKind.support : supportKind;
+}
+function getSupportMessage(supportKind) {
+  return typeof supportKind === "object" ? supportKind.message : void 0;
+}
+function getSupportMessageSuppression(supportKind) {
+  return typeof supportKind === "object" ? supportKind.suppress : void 0;
+}
 function validateSupportKind(supportKind, adapterName, logger, featureName, hasCorrectConfig) {
-  if (supportKind === STABLE) {
+  const supportValue = unwrapSupportKind(supportKind);
+  const message = getSupportMessage(supportKind);
+  const suppress = getSupportMessageSuppression(supportKind);
+  if (!supportValue) {
+    return false;
+  }
+  if (supportValue === AdapterFeatureStability.STABLE) {
     return true;
-  } else if (supportKind === DEPRECATED) {
-    featureIsDeprecated(adapterName, logger, featureName);
-  } else if (supportKind === EXPERIMENTAL) {
-    featureIsExperimental(adapterName, logger, featureName);
+  } else if (hasCorrectConfig()) {
+    logFeatureSupport(adapterName, logger, featureName, supportValue, message, suppress);
   }
-  if (hasCorrectConfig() && supportKind === UNSUPPORTED) {
-    featureIsUnsupported(adapterName, logger, featureName);
-    return false;
-  } else {
-    return true;
+  return false;
+}
+function logFeatureSupport(adapterName, logger, featureName, supportKind, adapterMessage, suppress) {
+  if (!suppress) {
+    switch (supportKind) {
+      case AdapterFeatureStability.STABLE:
+        break;
+      case AdapterFeatureStability.DEPRECATED:
+        logger.warn(
+          "config",
+          `The adapter ${adapterName} has deprecated its support for "${featureName}", and future compatibility is not guaranteed. The adapter may completely remove support for this feature without warning.`
+        );
+        break;
+      case AdapterFeatureStability.EXPERIMENTAL:
+        logger.warn(
+          "config",
+          `The adapter ${adapterName} provides experimental support for "${featureName}". You may experience issues or breaking changes until this feature is fully supported by the adapter.`
+        );
+        break;
+      case AdapterFeatureStability.LIMITED:
+        logger.warn(
+          "config",
+          `The adapter ${adapterName} has limited support for "${featureName}". Certain features may not work as expected.`
+        );
+        break;
+      case AdapterFeatureStability.UNSUPPORTED:
+        logger.error(
+          "config",
+          `The adapter ${adapterName} does not currently support the feature "${featureName}". Your project may not build correctly.`
+        );
+        break;
+    }
+  }
+  if (adapterMessage && suppress !== "all") {
+    logger.warn("adapter", adapterMessage);
   }
 }
-function featureIsUnsupported(adapterName, logger, featureName) {
-  logger.error(
-    "config",
-    `The adapter ${adapterName} doesn't currently support the feature "${featureName}".`
-  );
-}
-function featureIsExperimental(adapterName, logger, featureName) {
-  logger.warn(
-    "config",
-    `The adapter ${adapterName} provides experimental support for "${featureName}". You may experience issues or breaking changes until this feature is fully supported by the adapter.`
-  );
-}
-function featureIsDeprecated(adapterName, logger, featureName) {
-  logger.warn(
-    "config",
-    `The adapter ${adapterName} has deprecated its support for "${featureName}", and future compatibility is not guaranteed. The adapter may completely remove support for this feature without warning.`
-  );
-}
-const SHARP_SERVICE = "astro/assets/services/sharp";
-const SQUOOSH_SERVICE = "astro/assets/services/squoosh";
-function validateAssetsFeature(assets, adapterName, config, logger) {
-  const {
-    supportKind = UNSUPPORTED,
-    isSharpCompatible = false,
-    isSquooshCompatible = false
-  } = assets;
-  if (config?.image?.service?.entrypoint === SHARP_SERVICE && !isSharpCompatible) {
-    logger.warn(
-      null,
-      `The currently selected adapter \`${adapterName}\` is not compatible with the image service "Sharp".`
-    );
-    return false;
-  }
-  if (config?.image?.service?.entrypoint === SQUOOSH_SERVICE && !isSquooshCompatible) {
-    logger.warn(
-      null,
-      `The currently selected adapter \`${adapterName}\` is not compatible with the image service "Squoosh".`
-    );
-    return false;
-  }
-  return validateSupportKind(supportKind, adapterName, logger, "assets", () => true);
+function getAdapterStaticRecommendation(adapterName) {
+  return {
+    "@astrojs/vercel/static": "Update your configuration to use `@astrojs/vercel/serverless` to unlock server-side rendering capabilities."
+  }[adapterName];
 }
 export {
+  AdapterFeatureStability,
+  getAdapterStaticRecommendation,
   validateSupportedFeatures
 };

node_modules/astro/dist/integrations/hooks.d.ts

@@ -1,10 +1,13 @@
 import fsMod from 'node:fs';
 import type { AddressInfo } from 'node:net';
 import type { InlineConfig, ViteDevServer } from 'vite';
-import type { AstroAdapter, AstroConfig, AstroSettings, RouteData, RouteOptions } from '../@types/astro.js';
 import type { SerializedSSRManifest } from '../core/app/types.js';
 import type { PageBuildData } from '../core/build/types.js';
 import type { Logger } from '../core/logger/core.js';
+import type { AstroSettings } from '../types/astro.js';
+import type { AstroConfig } from '../types/public/config.js';
+import type { IntegrationResolvedRoute, RouteOptions, RouteToHeaders } from '../types/public/integrations.js';
+import type { RouteData } from '../types/public/internal.js';
 export declare function getToolbarServerCommunicationHelpers(server: ViteDevServer): {
     /**
      * Send a message to the dev toolbar that an app can listen for. The payload can be any serializable data.
@@ -33,17 +36,20 @@ export declare function getToolbarServerCommunicationHelpers(server: ViteDevServ
         state: boolean;
     }) => void) => void;
 };
+export declare function normalizeCodegenDir(integrationName: string): string;
 export declare function normalizeInjectedTypeFilename(filename: string, integrationName: string): string;
-export declare function runHookConfigSetup({ settings, command, logger, isRestart, fs, }: {
+interface RunHookConfigSetup {
     settings: AstroSettings;
     command: 'dev' | 'build' | 'preview' | 'sync';
     logger: Logger;
     isRestart?: boolean;
     fs?: typeof fsMod;
-}): Promise<AstroSettings>;
-export declare function runHookConfigDone({ settings, logger, }: {
+}
+export declare function runHookConfigSetup({ settings, command, logger, isRestart, fs, }: RunHookConfigSetup): Promise<AstroSettings>;
+export declare function runHookConfigDone({ settings, logger, command, }: {
     settings: AstroSettings;
     logger: Logger;
+    command?: 'dev' | 'build' | 'preview' | 'sync';
 }): Promise<void>;
 export declare function runHookServerSetup({ config, server, logger, }: {
     config: AstroConfig;
@@ -59,9 +65,9 @@ export declare function runHookServerDone({ config, logger, }: {
     config: AstroConfig;
     logger: Logger;
 }): Promise<void>;
-export declare function runHookBuildStart({ config, logging, }: {
+export declare function runHookBuildStart({ config, logger, }: {
     config: AstroConfig;
-    logging: Logger;
+    logger: Logger;
 }): Promise<void>;
 export declare function runHookBuildSetup({ config, vite, pages, target, logger, }: {
     config: AstroConfig;
@@ -78,22 +84,27 @@ type RunHookBuildSsr = {
     middlewareEntryPoint: URL | undefined;
 };
 export declare function runHookBuildSsr({ config, manifest, logger, entryPoints, middlewareEntryPoint, }: RunHookBuildSsr): Promise<void>;
-export declare function runHookBuildGenerated({ config, logger, }: {
-    config: AstroConfig;
+export declare function runHookBuildGenerated({ settings, logger, experimentalRouteToHeaders, }: {
+    settings: AstroSettings;
     logger: Logger;
+    experimentalRouteToHeaders: RouteToHeaders;
 }): Promise<void>;
 type RunHookBuildDone = {
-    config: AstroConfig;
+    settings: AstroSettings;
     pages: string[];
     routes: RouteData[];
-    logging: Logger;
-    cacheManifest: boolean;
+    logger: Logger;
 };
-export declare function runHookBuildDone({ config, pages, routes, logging, cacheManifest, }: RunHookBuildDone): Promise<void>;
+export declare function runHookBuildDone({ settings, pages, routes, logger }: RunHookBuildDone): Promise<void>;
 export declare function runHookRouteSetup({ route, settings, logger, }: {
     route: RouteOptions;
     settings: AstroSettings;
     logger: Logger;
 }): Promise<void>;
-export declare function isFunctionPerRouteEnabled(adapter: AstroAdapter | undefined): boolean;
+export declare function runHookRoutesResolved({ routes, settings, logger, }: {
+    routes: Array<RouteData>;
+    settings: AstroSettings;
+    logger: Logger;
+}): Promise<void>;
+export declare function toIntegrationResolvedRoute(route: RouteData): IntegrationResolvedRoute;
 export {};

node_modules/astro/dist/integrations/hooks.js

@@ -1,18 +1,24 @@
 import fsMod from "node:fs";
 import { fileURLToPath } from "node:url";
 import { bold } from "kleur/colors";
+import { mergeConfig as mergeViteConfig } from "vite";
 import astroIntegrationActionsRouteHandler from "../actions/integration.js";
 import { isActionsFilePresent } from "../actions/utils.js";
+import { CONTENT_LAYER_TYPE } from "../content/consts.js";
+import { globalContentLayer } from "../content/content-layer.js";
+import { globalContentConfigObserver } from "../content/utils.js";
 import { buildClientDirectiveEntrypoint } from "../core/client-directive/index.js";
 import { mergeConfig } from "../core/config/index.js";
-import { isServerLikeOutput } from "../core/util.js";
+import { validateConfigRefined } from "../core/config/validate.js";
+import { validateSetAdapter } from "../core/dev/adapter-validation.js";
+import { getClientOutputDirectory } from "../prerender/utils.js";
 import { validateSupportedFeatures } from "./features-validation.js";
 async function withTakingALongTimeMsg({
   name,
   hookName,
-  hookResult,
-  timeoutMs = 3e3,
-  logger
+  hookFn,
+  logger,
+  integrationLogger
 }) {
   const timeout = setTimeout(() => {
     logger.info(
@@ -21,10 +27,36 @@ async function withTakingALongTimeMsg({
         JSON.stringify(hookName)
       )}...`
     );
-  }, timeoutMs);
-  const result = await hookResult;
-  clearTimeout(timeout);
-  return result;
+  }, 3e3);
+  try {
+    return await hookFn();
+  } catch (err) {
+    integrationLogger.error(
+      `An unhandled error occurred while running the ${bold(JSON.stringify(hookName))} hook`
+    );
+    throw err;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function runHookInternal({
+  integration,
+  hookName,
+  logger,
+  params
+}) {
+  const hook = integration?.hooks?.[hookName];
+  const integrationLogger = getLogger(integration, logger);
+  if (hook) {
+    await withTakingALongTimeMsg({
+      name: integration.name,
+      hookName,
+      hookFn: () => hook(Object.assign(params(), { logger: integrationLogger })),
+      logger,
+      integrationLogger
+    });
+  }
+  return { integrationLogger };
 }
 const Loggers = /* @__PURE__ */ new WeakMap();
 function getLogger(integration, logger) {
@@ -73,13 +105,16 @@ function getToolbarServerCommunicationHelpers(server) {
   };
 }
 const SAFE_CHARS_RE = /[^\w.-]/g;
+function normalizeCodegenDir(integrationName) {
+  return `./integrations/${integrationName.replace(SAFE_CHARS_RE, "_")}/`;
+}
 function normalizeInjectedTypeFilename(filename, integrationName) {
   if (!filename.endsWith(".d.ts")) {
     throw new Error(
       `Integration ${bold(integrationName)} is injecting a type that does not end with "${bold(".d.ts")}"`
     );
   }
-  return `./integrations/${integrationName.replace(SAFE_CHARS_RE, "_")}/${filename.replace(SAFE_CHARS_RE, "_")}`;
+  return `${normalizeCodegenDir(integrationName)}${filename.replace(SAFE_CHARS_RE, "_")}`;
 }
 async function runHookConfigSetup({
   settings,
@@ -89,10 +124,13 @@ async function runHookConfigSetup({
   fs = fsMod
 }) {
   if (settings.config.adapter) {
-    settings.config.integrations.push(settings.config.adapter);
+    settings.config.integrations.unshift(settings.config.adapter);
   }
-  if (await isActionsFilePresent(fs, settings.config.srcDir)) {
-    settings.config.integrations.push(astroIntegrationActionsRouteHandler({ settings }));
+  const actionsFilename = await isActionsFilePresent(fs, settings.config.srcDir);
+  if (actionsFilename) {
+    settings.config.integrations.push(
+      astroIntegrationActionsRouteHandler({ settings, filename: actionsFilename })
+    );
   }
   let updatedConfig = { ...settings.config };
   let updatedSettings = { ...settings, config: updatedConfig };
@@ -100,174 +138,180 @@ async function runHookConfigSetup({
   let astroJSXRenderer = null;
   for (let i = 0; i < updatedConfig.integrations.length; i++) {
     const integration = updatedConfig.integrations[i];
-    if (integration.hooks?.["astro:config:setup"]) {
-      let addPageExtension2 = function(...input) {
-        const exts = input.flat(Infinity).map((ext) => `.${ext.replace(/^\./, "")}`);
-        updatedSettings.pageExtensions.push(...exts);
-      }, addContentEntryType2 = function(contentEntryType) {
-        updatedSettings.contentEntryTypes.push(contentEntryType);
-      }, addDataEntryType2 = function(dataEntryType) {
-        updatedSettings.dataEntryTypes.push(dataEntryType);
-      };
-      var addPageExtension = addPageExtension2, addContentEntryType = addContentEntryType2, addDataEntryType = addDataEntryType2;
-      const integrationLogger = getLogger(integration, logger);
-      const hooks = {
-        config: updatedConfig,
-        command,
-        isRestart,
-        addRenderer(renderer) {
-          if (!renderer.name) {
-            throw new Error(`Integration ${bold(integration.name)} has an unnamed renderer.`);
-          }
-          if (!renderer.serverEntrypoint) {
-            throw new Error(`Renderer ${bold(renderer.name)} does not provide a serverEntrypoint.`);
-          }
-          if (renderer.name === "astro:jsx") {
-            astroJSXRenderer = renderer;
-          } else {
-            updatedSettings.renderers.push(renderer);
-          }
-        },
-        injectScript: (stage, content) => {
-          updatedSettings.scripts.push({ stage, content });
-        },
-        updateConfig: (newConfig) => {
-          updatedConfig = mergeConfig(updatedConfig, newConfig);
-          return { ...updatedConfig };
-        },
-        injectRoute: (injectRoute) => {
-          if (injectRoute.entrypoint == null && "entryPoint" in injectRoute) {
-            logger.warn(
-              null,
-              `The injected route "${injectRoute.pattern}" by ${integration.name} specifies the entry point with the "entryPoint" property. This property is deprecated, please use "entrypoint" instead.`
+    const { integrationLogger } = await runHookInternal({
+      integration,
+      hookName: "astro:config:setup",
+      logger,
+      params: () => {
+        const hooks = {
+          config: updatedConfig,
+          command,
+          isRestart,
+          addRenderer(renderer) {
+            if (!renderer.name) {
+              throw new Error(`Integration ${bold(integration.name)} has an unnamed renderer.`);
+            }
+            if (!renderer.serverEntrypoint) {
+              throw new Error(
+                `Renderer ${bold(renderer.name)} does not provide a serverEntrypoint.`
+              );
+            }
+            if (renderer.name === "astro:jsx") {
+              astroJSXRenderer = renderer;
+            } else {
+              updatedSettings.renderers.push(renderer);
+            }
+          },
+          injectScript: (stage, content) => {
+            updatedSettings.scripts.push({ stage, content });
+          },
+          updateConfig: (newConfig) => {
+            updatedConfig = mergeConfig(updatedConfig, newConfig);
+            return { ...updatedConfig };
+          },
+          injectRoute: (injectRoute) => {
+            if (injectRoute.entrypoint == null && "entryPoint" in injectRoute) {
+              logger.warn(
+                null,
+                `The injected route "${injectRoute.pattern}" by ${integration.name} specifies the entry point with the "entryPoint" property. This property is deprecated, please use "entrypoint" instead.`
+              );
+              injectRoute.entrypoint = injectRoute.entryPoint;
+            }
+            updatedSettings.injectedRoutes.push({ ...injectRoute, origin: "external" });
+          },
+          addWatchFile: (path) => {
+            updatedSettings.watchFiles.push(path instanceof URL ? fileURLToPath(path) : path);
+          },
+          addDevToolbarApp: (entrypoint) => {
+            updatedSettings.devToolbarApps.push(entrypoint);
+          },
+          addClientDirective: ({ name, entrypoint }) => {
+            if (updatedSettings.clientDirectives.has(name) || addedClientDirectives.has(name)) {
+              throw new Error(
+                `The "${integration.name}" integration is trying to add the "${name}" client directive, but it already exists.`
+              );
+            }
+            addedClientDirectives.set(
+              name,
+              buildClientDirectiveEntrypoint(name, entrypoint, settings.config.root)
             );
-            injectRoute.entrypoint = injectRoute.entryPoint;
-          }
-          updatedSettings.injectedRoutes.push(injectRoute);
-        },
-        addWatchFile: (path) => {
-          updatedSettings.watchFiles.push(path instanceof URL ? fileURLToPath(path) : path);
-        },
-        addDevOverlayPlugin: (entrypoint) => {
-          hooks.addDevToolbarApp(entrypoint);
-        },
-        addDevToolbarApp: (entrypoint) => {
-          updatedSettings.devToolbarApps.push(entrypoint);
-        },
-        addClientDirective: ({ name, entrypoint }) => {
-          if (updatedSettings.clientDirectives.has(name) || addedClientDirectives.has(name)) {
-            throw new Error(
-              `The "${integration.name}" integration is trying to add the "${name}" client directive, but it already exists.`
+          },
+          addMiddleware: ({ order, entrypoint }) => {
+            if (typeof updatedSettings.middlewares[order] === "undefined") {
+              throw new Error(
+                `The "${integration.name}" integration is trying to add middleware but did not specify an order.`
+              );
+            }
+            logger.debug(
+              "middleware",
+              `The integration ${integration.name} has added middleware that runs ${order === "pre" ? "before" : "after"} any application middleware you define.`
             );
+            updatedSettings.middlewares[order].push(
+              typeof entrypoint === "string" ? entrypoint : fileURLToPath(entrypoint)
+            );
+          },
+          createCodegenDir: () => {
+            const codegenDir = new URL(normalizeCodegenDir(integration.name), settings.dotAstroDir);
+            fs.mkdirSync(codegenDir, { recursive: true });
+            return codegenDir;
           }
-          addedClientDirectives.set(
-            name,
-            buildClientDirectiveEntrypoint(name, entrypoint, settings.config.root)
+        };
+        function addPageExtension(...input) {
+          const exts = input.flat(Infinity).map(
+            (ext) => `.${ext.replace(/^\./, "")}`
           );
-        },
-        addMiddleware: ({ order, entrypoint }) => {
-          if (typeof updatedSettings.middlewares[order] === "undefined") {
-            throw new Error(
-              `The "${integration.name}" integration is trying to add middleware but did not specify an order.`
-            );
-          }
-          logger.debug(
-            "middleware",
-            `The integration ${integration.name} has added middleware that runs ${order === "pre" ? "before" : "after"} any application middleware you define.`
-          );
-          updatedSettings.middlewares[order].push(entrypoint);
-        },
-        logger: integrationLogger
-      };
-      Object.defineProperty(hooks, "addPageExtension", {
-        value: addPageExtension2,
-        writable: false,
-        enumerable: false
-      });
-      Object.defineProperty(hooks, "addContentEntryType", {
-        value: addContentEntryType2,
-        writable: false,
-        enumerable: false
-      });
-      Object.defineProperty(hooks, "addDataEntryType", {
-        value: addDataEntryType2,
-        writable: false,
-        enumerable: false
-      });
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:config:setup",
-        hookResult: integration.hooks["astro:config:setup"](hooks),
-        logger
-      });
-      for (const [name, compiled] of addedClientDirectives) {
-        updatedSettings.clientDirectives.set(name, await compiled);
+          updatedSettings.pageExtensions.push(...exts);
+        }
+        function addContentEntryType(contentEntryType) {
+          updatedSettings.contentEntryTypes.push(contentEntryType);
+        }
+        function addDataEntryType(dataEntryType) {
+          updatedSettings.dataEntryTypes.push(dataEntryType);
+        }
+        Object.defineProperty(hooks, "addPageExtension", {
+          value: addPageExtension,
+          writable: false,
+          enumerable: false
+        });
+        Object.defineProperty(hooks, "addContentEntryType", {
+          value: addContentEntryType,
+          writable: false,
+          enumerable: false
+        });
+        Object.defineProperty(hooks, "addDataEntryType", {
+          value: addDataEntryType,
+          writable: false,
+          enumerable: false
+        });
+        return hooks;
       }
+    });
+    for (const [name, compiled] of addedClientDirectives) {
+      updatedSettings.clientDirectives.set(name, await compiled);
+    }
+    try {
+      updatedConfig = await validateConfigRefined(updatedConfig);
+    } catch (error) {
+      integrationLogger.error("An error occurred while updating the config");
+      throw error;
     }
   }
   if (astroJSXRenderer) {
     updatedSettings.renderers.push(astroJSXRenderer);
   }
+  if (updatedConfig.i18n && typeof updatedConfig.i18n.routing !== "string") {
+    updatedConfig.i18n.routing.redirectToDefaultLocale ??= updatedConfig.i18n.routing.prefixDefaultLocale || false;
+  }
   updatedSettings.config = updatedConfig;
   return updatedSettings;
 }
 async function runHookConfigDone({
   settings,
-  logger
+  logger,
+  command
 }) {
   for (const integration of settings.config.integrations) {
-    if (integration?.hooks?.["astro:config:done"]) {
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:config:done",
-        hookResult: integration.hooks["astro:config:done"]({
-          config: settings.config,
-          setAdapter(adapter) {
-            if (settings.adapter && settings.adapter.name !== adapter.name) {
-              throw new Error(
-                `Integration "${integration.name}" conflicts with "${settings.adapter.name}". You can only configure one deployment integration.`
-              );
-            }
-            if (!adapter.supportedAstroFeatures) {
-              throw new Error(
-                `The adapter ${adapter.name} doesn't provide a feature map. It is required in Astro 4.0.`
-              );
-            } else {
-              const validationResult = validateSupportedFeatures(
-                adapter.name,
-                adapter.supportedAstroFeatures,
-                settings.config,
-                // SAFETY: we checked before if it's not present, and we throw an error
-                adapter.adapterFeatures,
-                logger
-              );
-              for (const [featureName, supported] of Object.entries(validationResult)) {
-                if (!supported && featureName !== "assets") {
-                  logger.error(
-                    null,
-                    `The adapter ${adapter.name} doesn't support the feature ${featureName}. Your project won't be built. You should not use it.`
-                  );
-                }
-              }
-            }
-            settings.adapter = adapter;
-          },
-          injectTypes(injectedType) {
-            const normalizedFilename = normalizeInjectedTypeFilename(
-              injectedType.filename,
-              integration.name
+    await runHookInternal({
+      integration,
+      hookName: "astro:config:done",
+      logger,
+      params: () => ({
+        config: settings.config,
+        setAdapter(adapter) {
+          validateSetAdapter(logger, settings, adapter, integration.name, command);
+          if (adapter.adapterFeatures?.buildOutput !== "static") {
+            settings.buildOutput = "server";
+          }
+          if (!adapter.supportedAstroFeatures) {
+            throw new Error(
+              `The adapter ${adapter.name} doesn't provide a feature map. It is required in Astro 4.0.`
             );
-            settings.injectedTypes.push({
-              filename: normalizedFilename,
-              content: injectedType.content
-            });
-            return new URL(normalizedFilename, settings.dotAstroDir);
-          },
-          logger: getLogger(integration, logger)
-        }),
-        logger
-      });
-    }
+          } else {
+            validateSupportedFeatures(
+              adapter.name,
+              adapter.supportedAstroFeatures,
+              settings,
+              logger
+            );
+          }
+          settings.adapter = adapter;
+        },
+        injectTypes(injectedType) {
+          const normalizedFilename = normalizeInjectedTypeFilename(
+            injectedType.filename,
+            integration.name
+          );
+          settings.injectedTypes.push({
+            filename: normalizedFilename,
+            content: injectedType.content
+          });
+          return new URL(normalizedFilename, settings.dotAstroDir);
+        },
+        get buildOutput() {
+          return settings.buildOutput;
+        }
+      })
+    });
   }
 }
 async function runHookServerSetup({
@@ -275,19 +319,28 @@ async function runHookServerSetup({
   server,
   logger
 }) {
-  for (const integration of config.integrations) {
-    if (integration?.hooks?.["astro:server:setup"]) {
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:server:setup",
-        hookResult: integration.hooks["astro:server:setup"]({
-          server,
-          logger: getLogger(integration, logger),
-          toolbar: getToolbarServerCommunicationHelpers(server)
-        }),
-        logger
-      });
+  let refreshContent;
+  refreshContent = async (options) => {
+    const contentConfig = globalContentConfigObserver.get();
+    if (contentConfig.status !== "loaded" || !Object.values(contentConfig.config.collections).some(
+      (collection) => collection.type === CONTENT_LAYER_TYPE
+    )) {
+      return;
     }
+    const contentLayer = await globalContentLayer.get();
+    await contentLayer?.sync(options);
+  };
+  for (const integration of config.integrations) {
+    await runHookInternal({
+      integration,
+      hookName: "astro:server:setup",
+      logger,
+      params: () => ({
+        server,
+        toolbar: getToolbarServerCommunicationHelpers(server),
+        refreshContent
+      })
+    });
   }
 }
 async function runHookServerStart({
@@ -296,17 +349,12 @@ async function runHookServerStart({
   logger
 }) {
   for (const integration of config.integrations) {
-    if (integration?.hooks?.["astro:server:start"]) {
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:server:start",
-        hookResult: integration.hooks["astro:server:start"]({
-          address,
-          logger: getLogger(integration, logger)
-        }),
-        logger
-      });
-    }
+    await runHookInternal({
+      integration,
+      hookName: "astro:server:start",
+      logger,
+      params: () => ({ address })
+    });
   }
 }
 async function runHookServerDone({
@@ -314,32 +362,25 @@ async function runHookServerDone({
   logger
 }) {
   for (const integration of config.integrations) {
-    if (integration?.hooks?.["astro:server:done"]) {
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:server:done",
-        hookResult: integration.hooks["astro:server:done"]({
-          logger: getLogger(integration, logger)
-        }),
-        logger
-      });
-    }
+    await runHookInternal({
+      integration,
+      hookName: "astro:server:done",
+      logger,
+      params: () => ({})
+    });
   }
 }
 async function runHookBuildStart({
   config,
-  logging
+  logger
 }) {
   for (const integration of config.integrations) {
-    if (integration?.hooks?.["astro:build:start"]) {
-      const logger = getLogger(integration, logging);
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:build:start",
-        hookResult: integration.hooks["astro:build:start"]({ logger }),
-        logger: logging
-      });
-    }
+    await runHookInternal({
+      integration,
+      hookName: "astro:build:start",
+      logger,
+      params: () => ({})
+    });
   }
 }
 async function runHookBuildSetup({
@@ -351,23 +392,20 @@ async function runHookBuildSetup({
 }) {
   let updatedConfig = vite;
   for (const integration of config.integrations) {
-    if (integration?.hooks?.["astro:build:setup"]) {
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:build:setup",
-        hookResult: integration.hooks["astro:build:setup"]({
-          vite,
-          pages,
-          target,
-          updateConfig: (newConfig) => {
-            updatedConfig = mergeConfig(updatedConfig, newConfig);
-            return { ...updatedConfig };
-          },
-          logger: getLogger(integration, logger)
-        }),
-        logger
-      });
-    }
+    await runHookInternal({
+      integration,
+      hookName: "astro:build:setup",
+      logger,
+      params: () => ({
+        vite,
+        pages,
+        target,
+        updateConfig: (newConfig) => {
+          updatedConfig = mergeViteConfig(updatedConfig, newConfig);
+          return { ...updatedConfig };
+        }
+      })
+    });
   }
   return updatedConfig;
 }
@@ -378,66 +416,56 @@ async function runHookBuildSsr({
   entryPoints,
   middlewareEntryPoint
 }) {
+  const entryPointsMap = /* @__PURE__ */ new Map();
+  for (const [key, value] of entryPoints) {
+    entryPointsMap.set(toIntegrationRouteData(key), value);
+  }
   for (const integration of config.integrations) {
-    if (integration?.hooks?.["astro:build:ssr"]) {
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:build:ssr",
-        hookResult: integration.hooks["astro:build:ssr"]({
-          manifest,
-          entryPoints,
-          middlewareEntryPoint,
-          logger: getLogger(integration, logger)
-        }),
-        logger
-      });
-    }
+    await runHookInternal({
+      integration,
+      hookName: "astro:build:ssr",
+      logger,
+      params: () => ({
+        manifest,
+        entryPoints: entryPointsMap,
+        middlewareEntryPoint
+      })
+    });
   }
 }
 async function runHookBuildGenerated({
-  config,
-  logger
+  settings,
+  logger,
+  experimentalRouteToHeaders
 }) {
-  const dir = isServerLikeOutput(config) ? config.build.client : config.outDir;
-  for (const integration of config.integrations) {
-    if (integration?.hooks?.["astro:build:generated"]) {
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:build:generated",
-        hookResult: integration.hooks["astro:build:generated"]({
-          dir,
-          logger: getLogger(integration, logger)
-        }),
-        logger
-      });
-    }
+  const dir = settings.buildOutput === "server" ? settings.config.build.client : settings.config.outDir;
+  for (const integration of settings.config.integrations) {
+    await runHookInternal({
+      integration,
+      hookName: "astro:build:generated",
+      logger,
+      params: () => ({ dir, experimentalRouteToHeaders })
+    });
   }
 }
-async function runHookBuildDone({
-  config,
-  pages,
-  routes,
-  logging,
-  cacheManifest
-}) {
-  const dir = isServerLikeOutput(config) ? config.build.client : config.outDir;
+async function runHookBuildDone({ settings, pages, routes, logger }) {
+  const dir = getClientOutputDirectory(settings);
   await fsMod.promises.mkdir(dir, { recursive: true });
-  for (const integration of config.integrations) {
-    if (integration?.hooks?.["astro:build:done"]) {
-      const logger = getLogger(integration, logging);
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:build:done",
-        hookResult: integration.hooks["astro:build:done"]({
-          pages: pages.map((p) => ({ pathname: p })),
-          dir,
-          routes,
-          logger,
-          cacheManifest
-        }),
-        logger: logging
-      });
-    }
+  const integrationRoutes = routes.map(toIntegrationRouteData);
+  for (const integration of settings.config.integrations) {
+    await runHookInternal({
+      integration,
+      hookName: "astro:build:done",
+      logger,
+      params: () => ({
+        pages: pages.map((p) => ({ pathname: p })),
+        dir,
+        routes: integrationRoutes,
+        assets: new Map(
+          routes.filter((r) => r.distURL !== void 0).map((r) => [r.route, r.distURL])
+        )
+      })
+    });
   }
 }
 async function runHookRouteSetup({
@@ -447,21 +475,15 @@ async function runHookRouteSetup({
 }) {
   const prerenderChangeLogs = [];
   for (const integration of settings.config.integrations) {
-    if (integration?.hooks?.["astro:route:setup"]) {
-      const originalRoute = { ...route };
-      const integrationLogger = getLogger(integration, logger);
-      await withTakingALongTimeMsg({
-        name: integration.name,
-        hookName: "astro:route:setup",
-        hookResult: integration.hooks["astro:route:setup"]({
-          route,
-          logger: integrationLogger
-        }),
-        logger
-      });
-      if (route.prerender !== originalRoute.prerender) {
-        prerenderChangeLogs.push({ integrationName: integration.name, value: route.prerender });
-      }
+    const originalRoute = { ...route };
+    await runHookInternal({
+      integration,
+      hookName: "astro:route:setup",
+      logger,
+      params: () => ({ route })
+    });
+    if (route.prerender !== originalRoute.prerender) {
+      prerenderChangeLogs.push({ integrationName: integration.name, value: route.prerender });
     }
   }
   if (prerenderChangeLogs.length > 1) {
@@ -472,16 +494,57 @@ async function runHookRouteSetup({
     );
   }
 }
-function isFunctionPerRouteEnabled(adapter) {
-  if (adapter?.adapterFeatures?.functionPerRoute === true) {
-    return true;
-  } else {
-    return false;
+async function runHookRoutesResolved({
+  routes,
+  settings,
+  logger
+}) {
+  for (const integration of settings.config.integrations) {
+    await runHookInternal({
+      integration,
+      hookName: "astro:routes:resolved",
+      logger,
+      params: () => ({
+        routes: routes.map((route) => toIntegrationResolvedRoute(route))
+      })
+    });
   }
 }
+function toIntegrationResolvedRoute(route) {
+  return {
+    isPrerendered: route.prerender,
+    entrypoint: route.component,
+    pattern: route.route,
+    params: route.params,
+    origin: route.origin,
+    generate: route.generate,
+    patternRegex: route.pattern,
+    segments: route.segments,
+    type: route.type,
+    pathname: route.pathname,
+    redirect: route.redirect,
+    redirectRoute: route.redirectRoute ? toIntegrationResolvedRoute(route.redirectRoute) : void 0
+  };
+}
+function toIntegrationRouteData(route) {
+  return {
+    route: route.route,
+    component: route.component,
+    generate: route.generate,
+    params: route.params,
+    pathname: route.pathname,
+    segments: route.segments,
+    prerender: route.prerender,
+    redirect: route.redirect,
+    redirectRoute: route.redirectRoute ? toIntegrationRouteData(route.redirectRoute) : void 0,
+    type: route.type,
+    pattern: route.pattern,
+    distURL: route.distURL
+  };
+}
 export {
   getToolbarServerCommunicationHelpers,
-  isFunctionPerRouteEnabled,
+  normalizeCodegenDir,
   normalizeInjectedTypeFilename,
   runHookBuildDone,
   runHookBuildGenerated,
@@ -491,7 +554,9 @@ export {
   runHookConfigDone,
   runHookConfigSetup,
   runHookRouteSetup,
+  runHookRoutesResolved,
   runHookServerDone,
   runHookServerSetup,
-  runHookServerStart
+  runHookServerStart,
+  toIntegrationResolvedRoute
 };