astro 3.6.2 → 4.0.0-beta.1

package/dist/core/messages.d.ts

@@ -2,27 +2,20 @@ import type { ResolvedServerUrls } from 'vite';
 import type { ZodError } from 'zod';
 import { type ErrorWithMetadata } from './errors/index.js';
 /** Display  */
-export declare function req({ url, statusCode, reqTime, }: {
+export declare function req({ url, method, statusCode, reqTime, }: {
     url: string;
     statusCode: number;
+    method?: string;
     reqTime?: number;
 }): string;
-export declare function reload({ file }: {
-    file: string;
-}): string;
-export declare function hmr({ file, style }: {
-    file: string;
-    style?: boolean;
-}): string;
 /** Display server host and startup time */
-export declare function serverStart({ startupTime, resolvedUrls, host, base, isRestart, }: {
+export declare function serverStart({ startupTime, resolvedUrls, host, base, }: {
     startupTime: number;
     resolvedUrls: ResolvedServerUrls;
     host: string | boolean;
     base: string;
-    isRestart?: boolean;
 }): string;
-export declare function telemetryNotice(packageManager?: string): string;
+export declare function telemetryNotice(): string;
 export declare function telemetryEnabled(): string;
 export declare function telemetryDisabled(): string;
 export declare function telemetryReset(): string;

package/dist/core/messages.js

@@ -1,10 +1,10 @@
 import {
-  bgCyan,
   bgGreen,
   bgRed,
   bgWhite,
   bgYellow,
   black,
+  blue,
   bold,
   cyan,
   dim,
@@ -19,46 +19,31 @@ import {
   AstroUserError,
   CompilerError
 } from "./errors/index.js";
-import { emoji, padMultilineString } from "./util.js";
-const PREFIX_PADDING = 6;
+import { padMultilineString } from "./util.js";
 function req({
   url,
+  method,
   statusCode,
   reqTime
 }) {
-  let color = dim;
-  if (statusCode >= 500)
-    color = red;
-  else if (statusCode >= 400)
-    color = yellow;
-  else if (statusCode >= 300)
-    color = dim;
-  else if (statusCode >= 200)
-    color = green;
-  return `${bold(color(`${statusCode}`.padStart(PREFIX_PADDING)))} ${url.padStart(40)} ${reqTime ? dim(Math.round(reqTime) + "ms") : ""}`.trim();
-}
-function reload({ file }) {
-  return `${green("reload".padStart(PREFIX_PADDING))} ${file}`;
-}
-function hmr({ file, style = false }) {
-  return `${green("update".padStart(PREFIX_PADDING))} ${file}${style ? ` ${dim("style")}` : ""}`;
+  const color = statusCode >= 400 ? red : statusCode >= 300 ? yellow : blue;
+  return color(`[${statusCode}]`) + ` ` + (method && method !== "GET" ? color(method) + " " : "") + url + ` ` + (reqTime ? dim(Math.round(reqTime) + "ms") : "");
 }
 function serverStart({
   startupTime,
   resolvedUrls,
   host,
-  base,
-  isRestart = false
+  base
 }) {
-  const version = "3.6.2";
+  const version = "4.0.0-beta.1";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
   const localUrlMessages = resolvedUrls.local.map((url, i) => {
-    return `${i === 0 ? localPrefix : emptyPrefix}${bold(cyan(new URL(url).origin + base))}`;
+    return `${i === 0 ? localPrefix : emptyPrefix}${cyan(new URL(url).origin + base)}`;
   });
   const networkUrlMessages = resolvedUrls.network.map((url, i) => {
-    return `${i === 0 ? networkPrefix : emptyPrefix}${bold(cyan(new URL(url).origin + base))}`;
+    return `${i === 0 ? networkPrefix : emptyPrefix}${cyan(new URL(url).origin + base)}`;
   });
   if (networkUrlMessages.length === 0) {
     const networkLogging = getNetworkLogging(host);
@@ -69,55 +54,56 @@ function serverStart({
     }
   }
   const messages = [
-    `${emoji("\u{1F680} ", "")}${bgGreen(black(` astro `))} ${green(`v${version}`)} ${dim(
-      `${isRestart ? "re" : ""}started in ${Math.round(startupTime)}ms`
-    )}`,
+    "",
+    `${bgGreen(bold(` astro `))} ${green(`v${version}`)} ${dim(`ready in`)} ${Math.round(
+      startupTime
+    )} ${dim("ms")}`,
     "",
     ...localUrlMessages,
     ...networkUrlMessages,
     ""
   ];
-  return messages.filter((msg) => typeof msg === "string").map((msg) => `  ${msg}`).join("\n");
+  return messages.filter((msg) => typeof msg === "string").join("\n");
 }
-function telemetryNotice(packageManager = "npm") {
-  const headline = `${cyan("\u25C6")} Astro collects completely anonymous usage data.`;
-  const why = dim("  This optional program helps shape our roadmap.");
-  const disable = dim(`  Run \`${packageManager} run astro telemetry disable\` to opt-out.`);
-  const details = `  Details: ${underline("https://astro.build/telemetry")}`;
-  return [headline, why, disable, details].map((v) => "  " + v).join("\n");
+function telemetryNotice() {
+  const headline = blue(`\u25B6 Astro collects anonymous usage data.`);
+  const why = "  This information helps us improve Astro.";
+  const disable = `  Run "astro telemetry disable" to opt-out.`;
+  const details = `  ${cyan(underline("https://astro.build/telemetry"))}`;
+  return [headline, why, disable, details].join("\n");
 }
 function telemetryEnabled() {
-  return `${green("\u25C9")} Anonymous telemetry is now ${bgGreen(black(" enabled "))}
-  ${dim(
-    "Thank you for improving Astro!"
-  )}
-`;
+  return [
+    green("\u25B6 Anonymous telemetry ") + bgGreen(" enabled "),
+    `  Thank you for helping us improve Astro!`,
+    ``
+  ].join("\n");
 }
 function telemetryDisabled() {
-  return `${yellow("\u25EF")} Anonymous telemetry is now ${bgYellow(black(" disabled "))}
-  ${dim(
-    "We won't ever record your usage data."
-  )}
-`;
+  return [
+    green("\u25B6 Anonymous telemetry ") + bgGreen(" disabled "),
+    `  Astro is no longer collecting anonymous usage data.`,
+    ``
+  ].join("\n");
 }
 function telemetryReset() {
-  return `${cyan("\u25C6")} Anonymous telemetry has been ${bgCyan(black(" reset "))}
-  ${dim(
-    "You may be prompted again."
-  )}
-`;
+  return [green("\u25B6 Anonymous telemetry preferences reset."), ``].join("\n");
 }
 function fsStrictWarning() {
-  return yellow(
-    "\u26A0\uFE0F Serving with vite.server.fs.strict: false. Note that all files on your machine will be accessible to anyone on your network!"
-  );
+  const title = yellow(`\u25B6 ${bold("vite.server.fs.strict")} has been disabled!`);
+  const subtitle = `  Files on your machine are likely accessible on your network.`;
+  return `${title}
+${subtitle}
+`;
 }
 function prerelease({ currentVersion }) {
-  const tag = currentVersion.split("-").slice(1).join("-").replace(/\..*$/, "");
+  const tag = currentVersion.split("-").slice(1).join("-").replace(/\..*$/, "") || "unknown";
   const badge = bgYellow(black(` ${tag} `));
-  const headline = yellow(`\u25B6 This is a ${badge} prerelease build`);
-  const warning = `  Feedback? ${underline("https://astro.build/issues")}`;
-  return [headline, warning, ""].map((msg) => `  ${msg}`).join("\n");
+  const title = yellow(`\u25B6 This is a ${badge} prerelease build!`);
+  const subtitle = `  Report issues here: ${cyan(underline("https://astro.build/issues"))}`;
+  return `${title}
+${subtitle}
+`;
 }
 function success(message, tip) {
   const badge = bgGreen(black(` success `));
@@ -235,7 +221,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"3.6.2"}`
+        `v${"4.0.0-beta.1"}`
       )} ${headline}`
     );
   }
@@ -265,10 +251,8 @@ export {
   formatErrorMessage,
   fsStrictWarning,
   getNetworkLogging,
-  hmr,
   prerelease,
   printHelp,
-  reload,
   req,
   serverStart,
   success,

package/dist/core/middleware/callMiddleware.d.ts

@@ -1,5 +1,4 @@
 import type { APIContext, MiddlewareHandler } from '../../@types/astro.js';
-import type { Environment } from '../render/index.js';
 /**
  * Utility function that is in charge of calling the middleware.
  *
@@ -34,4 +33,4 @@ import type { Environment } from '../render/index.js';
  * @param apiContext The API context
  * @param responseFunction A callback function that should return a promise with the response
  */
-export declare function callMiddleware<R>(logger: Environment['logger'], onRequest: MiddlewareHandler<R>, apiContext: APIContext, responseFunction: () => Promise<R>): Promise<Response | R>;
+export declare function callMiddleware(onRequest: MiddlewareHandler, apiContext: APIContext, responseFunction: () => Promise<Response>): Promise<Response>;

package/dist/core/middleware/callMiddleware.js

@@ -1,7 +1,6 @@
-import { bold } from "kleur/colors";
 import { attachCookiesToResponse, responseHasCookies } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
-async function callMiddleware(logger, onRequest, apiContext, responseFunction) {
+async function callMiddleware(onRequest, apiContext, responseFunction) {
   let nextCalled = false;
   let responseFunctionPromise = void 0;
   const next = async () => {
@@ -11,13 +10,6 @@ async function callMiddleware(logger, onRequest, apiContext, responseFunction) {
   };
   let middlewarePromise = onRequest(apiContext, next);
   return await Promise.resolve(middlewarePromise).then(async (value) => {
-    if (isEndpointOutput(value)) {
-      logger.warn(
-        "middleware",
-        `Using simple endpoints can cause unexpected issues in the chain of middleware functions.
-It's strongly suggested to use full ${bold("Response")} objects.`
-      );
-    }
     if (nextCalled) {
       if (typeof value !== "undefined") {
         if (value instanceof Response === false) {
@@ -46,9 +38,6 @@ function ensureCookiesAttached(apiContext, response) {
   }
   return response;
 }
-function isEndpointOutput(endpointResult) {
-  return !(endpointResult instanceof Response) && typeof endpointResult === "object" && typeof endpointResult.body === "string";
-}
 export {
   callMiddleware
 };

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

@@ -1,6 +1,6 @@
-import type { MiddlewareEndpointHandler, Params } from '../../@types/astro.js';
+import type { MiddlewareHandler, Params } from '../../@types/astro.js';
 import { sequence } from './sequence.js';
-declare function defineMiddleware(fn: MiddlewareEndpointHandler): MiddlewareEndpointHandler;
+declare function defineMiddleware(fn: MiddlewareHandler): MiddlewareHandler;
 /**
  * Payload for creating a context to be passed to Astro middleware
  */

package/dist/core/middleware/sequence.d.ts

@@ -1,6 +1,6 @@
-import type { MiddlewareEndpointHandler } from '../../@types/astro.js';
+import type { MiddlewareHandler } from '../../@types/astro.js';
 /**
  *
  * It accepts one or more middleware handlers and makes sure that they are run in sequence.
  */
-export declare function sequence(...handlers: MiddlewareEndpointHandler[]): MiddlewareEndpointHandler;
+export declare function sequence(...handlers: MiddlewareHandler[]): MiddlewareHandler;

package/dist/core/pipeline.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentInstance, MiddlewareEndpointHandler } from '../@types/astro.js';
+import type { ComponentInstance, MiddlewareHandler } from '../@types/astro.js';
 import { type Environment, type RenderContext } from './render/index.js';
 type EndpointResultHandler = (originalRequest: Request, result: Response) => Promise<Response> | Response;
 export type PipelineHookFunction = (ctx: RenderContext, mod: ComponentInstance | undefined) => void;
@@ -25,7 +25,7 @@ export declare class Pipeline {
     /**
      * A middleware function that will be called before each request.
      */
-    setMiddlewareFunction(onRequest: MiddlewareEndpointHandler): void;
+    setMiddlewareFunction(onRequest: MiddlewareHandler): void;
     /**
      * Removes the current middleware function. Subsequent requests won't trigger any middleware.
      */

package/dist/core/pipeline.js

@@ -98,19 +98,14 @@ class Pipeline {
       case "fallback":
       case "redirect": {
         if (onRequest) {
-          return await callMiddleware(
-            env.logger,
-            onRequest,
-            apiContext,
-            () => {
-              return renderPage({
-                mod,
-                renderContext,
-                env,
-                cookies: apiContext.cookies
-              });
-            }
-          );
+          return await callMiddleware(onRequest, apiContext, () => {
+            return renderPage({
+              mod,
+              renderContext,
+              env,
+              cookies: apiContext.cookies
+            });
+          });
         } else {
           return await renderPage({
             mod,

package/dist/core/preview/static-preview-server.js

@@ -26,13 +26,13 @@ async function createStaticPreviewServer(settings, logger) {
     });
   } catch (err) {
     if (err instanceof Error) {
-      logger.error("astro", err.stack || err.message);
+      logger.error(null, err.stack || err.message);
     }
     throw err;
   }
   enableDestroy(previewServer.httpServer);
   logger.info(
-    null,
+    "SKIP_FORMAT",
     msg.serverStart({
       startupTime: performance.now() - startServerTime,
       resolvedUrls: previewServer.resolvedUrls ?? { local: [], network: [] },
@@ -50,8 +50,6 @@ async function createStaticPreviewServer(settings, logger) {
     host: getResolvedHostForHttpServer(settings.config.server.host),
     port: settings.config.server.port,
     closed,
-    // In Vite 5, `httpServer` may be a `Http2SecureServer`, but we know we are only starting a HTTP server
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     server: previewServer.httpServer,
     stop: async () => {
       await new Promise((resolve, reject) => {

package/dist/core/preview/vite-plugin-astro-preview.js

@@ -1,10 +1,9 @@
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
-import { version } from "vite";
 import { notFoundTemplate, subpathNotUsedTemplate } from "../../template/4xx.js";
+import { cleanUrl } from "../../vite-plugin-utils/index.js";
 import { stripBase } from "./util.js";
 const HAS_FILE_EXTENSION_REGEXP = /^.*\.[^\\]+$/;
-const IS_VITE_5 = version.startsWith("5.");
 function vitePluginAstroPreview(settings) {
   const { base, outDir, trailingSlash } = settings.config;
   return {
@@ -17,8 +16,7 @@ function vitePluginAstroPreview(settings) {
           res.end(subpathNotUsedTemplate(base, req.url));
           return;
         }
-        const strippedPathname = stripBase(req.url, base);
-        const pathname = new URL(strippedPathname, "https://a.b").pathname;
+        const pathname = cleanUrl(stripBase(req.url, base));
         const isRoot = pathname === "/";
         if (!isRoot) {
           const hasTrailingSlash = pathname.endsWith("/");
@@ -36,26 +34,38 @@ function vitePluginAstroPreview(settings) {
         next();
       });
       return () => {
-        const fourOhFourMiddleware = (req, res) => {
-          const errorPagePath = fileURLToPath(outDir + "/404.html");
-          if (fs.existsSync(errorPagePath)) {
-            res.statusCode = 404;
-            res.setHeader("Content-Type", "text/html;charset=utf-8");
-            res.end(fs.readFileSync(errorPagePath));
+        server.middlewares.use((req, res, next) => {
+          const pathname = cleanUrl(req.url);
+          if (pathname.endsWith("/")) {
+            const pathnameWithoutSlash = pathname.slice(0, -1);
+            const htmlPath = fileURLToPath(outDir + pathnameWithoutSlash + ".html");
+            if (fs.existsSync(htmlPath)) {
+              req.url = pathnameWithoutSlash + ".html";
+              return next();
+            }
           } else {
-            const pathname = stripBase(req.url, base);
-            res.statusCode = 404;
-            res.end(notFoundTemplate(pathname, "Not Found"));
-          }
-        };
-        if (IS_VITE_5) {
-          for (const middleware of server.middlewares.stack) {
-            if (middleware.handle.name === "vite404Middleware") {
-              middleware.handle = fourOhFourMiddleware;
+            const htmlPath = fileURLToPath(outDir + pathname + "/index.html");
+            if (fs.existsSync(htmlPath)) {
+              req.url = pathname + "/index.html";
+              return next();
             }
           }
-        } else {
-          server.middlewares.use(fourOhFourMiddleware);
+          next();
+        });
+        for (const middleware of server.middlewares.stack) {
+          if (middleware.handle.name === "vite404Middleware") {
+            middleware.handle = (req, res) => {
+              const errorPagePath = fileURLToPath(outDir + "/404.html");
+              if (fs.existsSync(errorPagePath)) {
+                res.statusCode = 404;
+                res.setHeader("Content-Type", "text/html;charset=utf-8");
+                res.end(fs.readFileSync(errorPagePath));
+              } else {
+                res.statusCode = 404;
+                res.end(notFoundTemplate(req.url, "Not Found"));
+              }
+            };
+          }
         }
       };
     }

package/dist/core/render/core.js

@@ -47,12 +47,6 @@ async function renderPage({ mod, renderContext, env, cookies }) {
     defaultLocale: renderContext.defaultLocale,
     routingStrategy: renderContext.routingStrategy
   });
-  if (mod.frontmatter && typeof mod.frontmatter === "object" && "draft" in mod.frontmatter) {
-    env.logger.warn(
-      "astro",
-      `The drafts feature is deprecated and used in ${renderContext.route.component}. You should migrate to content collections instead. See https://docs.astro.build/en/guides/content-collections/#filtering-collection-queries for more information.`
-    );
-  }
   const response = await runtimeRenderPage(
     result,
     Component,

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

@@ -22,5 +22,5 @@ export interface SSROptions {
     /**
      * Optional middlewares
      */
-    middleware?: AstroMiddlewareInstance<unknown>;
+    middleware?: AstroMiddlewareInstance;
 }

package/dist/core/render/result.js

@@ -53,7 +53,7 @@ class Slots {
     const result = this.#result;
     if (!Array.isArray(args)) {
       this.#logger.warn(
-        "Astro.slots.render",
+        null,
         `Expected second parameter to be an array, received a ${typeof args}. If you're trying to pass an array as a single argument and getting unexpected results, make sure you're passing your array as a item of an array. Ex: Astro.slots.render('default', [["Hello", "World"]])`
       );
     } else if (args.length > 0) {

package/dist/core/render/route-cache.js

@@ -58,10 +58,7 @@ class RouteCache {
   }
   set(route, entry) {
     if (this.mode === "production" && this.cache[route.component]?.staticPaths) {
-      this.logger.warn(
-        "routeCache",
-        `Internal Warning: route cache overwritten. (${route.component})`
-      );
+      this.logger.warn(null, `Internal Warning: route cache overwritten. (${route.component})`);
     }
     this.cache[route.component] = entry;
   }
@@ -75,7 +72,7 @@ function findPathItemByKey(staticPaths, params, route, logger) {
   if (matchedStaticPath) {
     return matchedStaticPath;
   }
-  logger.debug("findPathItemByKey", `Unexpected cache miss looking for ${paramsKey}`);
+  logger.debug("router", `findPathItemByKey() - Unexpected cache miss looking for ${paramsKey}`);
 }
 export {
   RouteCache,

package/dist/core/request.js

@@ -19,7 +19,7 @@ function createRequest({
   Object.defineProperties(request, {
     params: {
       get() {
-        logger.warn("deprecation", `Astro.request.params has been moved to Astro.params`);
+        logger.warn("deprecated", `Astro.request.params has been moved to Astro.params`);
         return void 0;
       }
     }
@@ -31,8 +31,8 @@ function createRequest({
       ...headersDesc,
       get() {
         logger.warn(
-          "ssg",
-          `Headers are not exposed in static (SSG) output mode. To enable headers: set \`output: "server"\` in your config file.`
+          null,
+          `\`Astro.request.headers\` is not available in "static" output mode. To enable header access: set \`output: "server"\` or \`output: "hybrid"\` in your config file.`
         );
         return _headers;
       }

package/dist/core/routing/manifest/create.js

@@ -1,3 +1,4 @@
+import { bold } from "kleur/colors";
 import { createRequire } from "module";
 import nodeFs from "node:fs";
 import path from "node:path";
@@ -115,12 +116,12 @@ function comparator(a, b) {
   }
   return a.file < b.file ? -1 : 1;
 }
-function injectedRouteToItem({ config, cwd }, { pattern, entryPoint }) {
+function injectedRouteToItem({ config, cwd }, { pattern, entrypoint }) {
   let resolved;
   try {
-    resolved = require2.resolve(entryPoint, { paths: [cwd || fileURLToPath(config.root)] });
+    resolved = require2.resolve(entrypoint, { paths: [cwd || fileURLToPath(config.root)] });
   } catch (e) {
-    resolved = fileURLToPath(new URL(entryPoint, config.root));
+    resolved = fileURLToPath(new URL(entrypoint, config.root));
   }
   const ext = path.extname(pattern);
   const type = resolved.endsWith(".astro") ? "page" : "endpoint";
@@ -147,7 +148,6 @@ function createRouteManifest({ settings, cwd, fsMod }, logger) {
   const validEndpointExtensions = /* @__PURE__ */ new Set([".js", ".ts"]);
   const localFs = fsMod ?? nodeFs;
   const prerender = getPrerenderDefault(settings.config);
-  const foundInvalidFileExtensions = /* @__PURE__ */ new Set();
   function walk(fs, dir, parentSegments, parentParams) {
     let items = [];
     fs.readdirSync(dir).forEach((basename) => {
@@ -163,10 +163,12 @@ function createRouteManifest({ settings, cwd, fsMod }, logger) {
         return;
       }
       if (!isDir && !validPageExtensions.has(ext) && !validEndpointExtensions.has(ext)) {
-        if (!foundInvalidFileExtensions.has(ext)) {
-          foundInvalidFileExtensions.add(ext);
-          logger.warn("astro", `Invalid file extension for Pages: ${ext}`);
-        }
+        logger.warn(
+          null,
+          `Unsupported file type ${bold(
+            resolved
+          )} found. Prefix filename with an underscore (\`_\`) to ignore.`
+        );
         return;
       }
       const segment = isDir ? basename : name;
@@ -248,19 +250,19 @@ function createRouteManifest({ settings, cwd, fsMod }, logger) {
     walk(localFs, fileURLToPath(pages), [], []);
   } else if (settings.injectedRoutes.length === 0) {
     const pagesDirRootRelative = pages.href.slice(settings.config.root.href.length);
-    logger.warn("astro", `Missing pages directory: ${pagesDirRootRelative}`);
+    logger.warn(null, `Missing pages directory: ${pagesDirRootRelative}`);
   }
   settings.injectedRoutes?.sort(
     (a, b) => (
       // sort injected routes in the same way as user-defined routes
       comparator(injectedRouteToItem({ config, cwd }, a), injectedRouteToItem({ config, cwd }, b))
     )
-  ).reverse().forEach(({ pattern: name, entryPoint, prerender: prerenderInjected }) => {
+  ).reverse().forEach(({ pattern: name, entrypoint, prerender: prerenderInjected }) => {
     let resolved;
     try {
-      resolved = require2.resolve(entryPoint, { paths: [cwd || fileURLToPath(config.root)] });
+      resolved = require2.resolve(entrypoint, { paths: [cwd || fileURLToPath(config.root)] });
     } catch (e) {
-      resolved = fileURLToPath(new URL(entryPoint, config.root));
+      resolved = fileURLToPath(new URL(entrypoint, config.root));
     }
     const component = slash(path.relative(cwd || fileURLToPath(config.root), resolved));
     const segments = removeLeadingForwardSlash(name).split(path.posix.sep).filter(Boolean).map((s) => {

package/dist/core/routing/validation.js

@@ -52,16 +52,16 @@ function validateGetStaticPathsResult(result, logger, route) {
     for (const [key, val] of Object.entries(pathObject.params)) {
       if (!(typeof val === "undefined" || typeof val === "string" || typeof val === "number")) {
         logger.warn(
-          "getStaticPaths",
-          `invalid path param: ${key}. A string, number or undefined value was expected, but got \`${JSON.stringify(
+          "router",
+          `getStaticPaths() returned an invalid path param: "${key}". A string, number or undefined value was expected, but got \`${JSON.stringify(
             val
           )}\`.`
         );
       }
       if (typeof val === "string" && val === "") {
         logger.warn(
-          "getStaticPaths",
-          `invalid path param: ${key}. \`undefined\` expected for an optional param, but got empty string.`
+          "router",
+          `getStaticPaths() returned an invalid path param: "${key}". \`undefined\` expected for an optional param, but got empty string.`
         );
       }
     }

package/dist/core/sync/index.js

@@ -64,7 +64,7 @@ async function syncInternal(settings, { logger, fs }) {
       switch (typesResult.reason) {
         case "no-content-dir":
         default:
-          logger.info("content", "No content directory found. Skipping type generation.");
+          logger.debug("types", "No content directory found. Skipping type generation.");
           return 0;
       }
     }
@@ -83,7 +83,7 @@ async function syncInternal(settings, { logger, fs }) {
   } finally {
     await tempViteServer.close();
   }
-  logger.info("content", `Types generated ${dim(getTimeStat(timerStart, performance.now()))}`);
+  logger.info(null, `Types generated ${dim(getTimeStat(timerStart, performance.now()))}`);
   await setUpEnvTs({ settings, logger, fs: fs ?? fsMod });
   return 0;
 }

package/dist/i18n/middleware.d.ts

@@ -1,6 +1,6 @@
-import type { MiddlewareEndpointHandler, SSRManifest } from '../@types/astro.js';
+import type { MiddlewareHandler, SSRManifest } from '../@types/astro.js';
 import type { PipelineHookFunction } from '../core/pipeline.js';
-export declare function createI18nMiddleware(i18n: SSRManifest['i18n'], base: SSRManifest['base'], trailingSlash: SSRManifest['trailingSlash']): MiddlewareEndpointHandler | undefined;
+export declare function createI18nMiddleware(i18n: SSRManifest['i18n'], base: SSRManifest['base'], trailingSlash: SSRManifest['trailingSlash']): MiddlewareHandler | undefined;
 /**
  * This pipeline hook attaches a `RouteData` object to the `Request`
  */

package/dist/i18n/vite-plugin-i18n.js

@@ -21,7 +21,7 @@ function astroInternationalization({
 						getLocaleAbsoluteUrl as _getLocaleAbsoluteUrl, 
 						getLocaleAbsoluteUrlList as _getLocaleAbsoluteUrlList,
 						 
-					} from "astro/i18n";
+					} from "astro/virtual-modules/i18n.js";
 					
 					const base =  ${JSON.stringify(settings.config.base)};
 					const trailingSlash =  ${JSON.stringify(settings.config.trailingSlash)};

package/dist/integrations/astroFeaturesValidation.d.ts

@@ -10,5 +10,5 @@ type ValidationResult = {
  * will throw a runtime error.
  *
  */
-export declare function validateSupportedFeatures(adapterName: string, featureMap: AstroFeatureMap | undefined, config: AstroConfig, logger: Logger): ValidationResult;
+export declare function validateSupportedFeatures(adapterName: string, featureMap: AstroFeatureMap, config: AstroConfig, logger: Logger): ValidationResult;
 export {};