astro 7.1.3 → 7.1.5

package/dist/core/cookies/cookies.js

@@ -49,7 +49,7 @@ class AstroCookies {
         name: key,
         value: DELETED_VALUE,
         expires: DELETED_EXPIRATION,
-        // Unset `expires` to to ensure that `expires` takes precedence.
+        // Unset `maxAge` to ensure that `expires` takes precedence.
         maxAge: void 0
       }),
       false

package/dist/core/create-vite.js

@@ -48,6 +48,7 @@ import { ServerIslandsState } from "./server-islands/shared-state.js";
 import { vitePluginServerIslands } from "./server-islands/vite-plugin-server-islands.js";
 import { vitePluginCacheProvider } from "./cache/vite-plugin.js";
 import { vitePluginSessionDriver } from "./session/vite-plugin.js";
+import { vitePluginLogger } from "./logger/vite-plugin.js";
 import { isObject } from "./util-runtime.js";
 import { vitePluginEnvironment } from "../vite-plugin-environment/index.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "./constants.js";
@@ -180,6 +181,7 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
       vitePluginServerIslands({ settings, logger, serverIslandsState }),
       vitePluginSessionDriver({ settings }),
       vitePluginCacheProvider({ settings }),
+      vitePluginLogger({ settings }),
       astroContainer(),
       astroHmrReloadPlugin(),
       vitePluginChromedevtools({ settings }),

package/dist/core/createMinimalViteDevServer.d.ts

@@ -5,4 +5,4 @@ import { type ViteDevServer, type Plugin } from 'vite';
  * NOTE: This is intentionally in its own module to avoid pulling `vite`'s heavy `createServer`
  * (and transitively Rollup) into every file that imports from `viteUtils.ts`.
  */
-export declare function createMinimalViteDevServer(plugins?: Plugin[]): Promise<ViteDevServer>;
+export declare function createMinimalViteDevServer(plugins?: Plugin[], root?: string): Promise<ViteDevServer>;

package/dist/core/createMinimalViteDevServer.js

@@ -1,12 +1,14 @@
 import { createServer } from "vite";
-async function createMinimalViteDevServer(plugins = []) {
+async function createMinimalViteDevServer(plugins = [], root) {
   return await createServer({
+    root,
     configFile: false,
     server: { middlewareMode: true, hmr: false, watch: null, ws: false },
     optimizeDeps: { noDiscovery: true },
     clearScreen: false,
     appType: "custom",
     ssr: { external: true },
+    resolve: { tsconfigPaths: true },
     plugins
   });
 }

package/dist/core/dev/dev.js

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

package/dist/core/errors/default-handler.d.ts

@@ -1,6 +1,6 @@
 import type { BaseApp, RenderErrorOptions } from '../app/base.js';
 import type { Pipeline } from '../base-pipeline.js';
-import type { ErrorHandler } from './handler.js';
+import { type ErrorHandler } from './handler.js';
 /**
  * The default error handler used in production SSR. Attempts to render the
  * matching error route (404.astro / 500.astro), falling back to a plain

package/dist/core/errors/default-handler.js

@@ -9,6 +9,7 @@ import { provideSession } from "../session/handler.js";
 import { validateHost } from "../app/validate-headers.js";
 import { getErrorRoutePath } from "../../i18n/error-routes.js";
 import { getOutputFilename } from "../output-filename.js";
+import { rewroteToEmptyErrorResponse } from "./handler.js";
 class DefaultErrorHandler {
   #app;
   #astroMiddleware;
@@ -82,6 +83,21 @@ class DefaultErrorHandler {
           errorState,
           this.#pagesHandler.handle.bind(this.#pagesHandler)
         );
+        if (rewroteToEmptyErrorResponse(
+          skipMiddleware,
+          errorRouteData,
+          errorState.routeData,
+          response2
+        )) {
+          return this.renderError(request, {
+            ...resolvedRenderOptions,
+            status,
+            error,
+            response: originalResponse,
+            skipMiddleware: true,
+            pathname: resolvedPathname
+          });
+        }
         const newResponse = mergeResponses(response2, originalResponse);
         prepareResponse(newResponse, resolvedRenderOptions);
         return newResponse;

package/dist/core/errors/dev-handler.d.ts

@@ -1,6 +1,6 @@
 import type { BaseApp, RenderErrorOptions } from '../app/base.js';
 import type { Pipeline } from '../base-pipeline.js';
-import type { ErrorHandler } from './handler.js';
+import { type ErrorHandler } from './handler.js';
 export interface DevErrorHandlerOptions {
     /**
      * Whether to inject CSP meta tags into the rendered error page response.

package/dist/core/errors/dev-handler.js

@@ -4,6 +4,7 @@ import { PagesHandler } from "../pages/handler.js";
 import { getCustom404Route, getCustom500Route } from "../routing/helpers.js";
 import { isAstroError } from "./index.js";
 import { MiddlewareNoDataOrNextCalled, MiddlewareNotAResponse } from "./errors-data.js";
+import { rewroteToEmptyErrorResponse } from "./handler.js";
 class DevErrorHandler {
   #app;
   #shouldInjectCspMetaTags;
@@ -46,6 +47,15 @@ class DevErrorHandler {
           errorState,
           this.#pagesHandler.handle.bind(this.#pagesHandler)
         );
+        if (rewroteToEmptyErrorResponse(skipMiddleware, routeData, errorState.routeData, response)) {
+          return this.renderError(request, {
+            ...resolvedRenderOptions,
+            status,
+            error,
+            skipMiddleware: true,
+            pathname: resolvedPathname
+          });
+        }
         if (error) {
           app.logger.error("router", error.stack || error.message);
         }

package/dist/core/errors/handler.d.ts

@@ -1,4 +1,5 @@
 import type { RenderErrorOptions } from '../app/base.js';
+import type { RouteData } from '../../types/public/index.js';
 /**
  * A strategy for rendering error responses (404, 500, etc.). Each execution
  * environment (prod SSR, build/prerender, dev server) supplies its own
@@ -7,3 +8,16 @@ import type { RenderErrorOptions } from '../app/base.js';
 export interface ErrorHandler {
     renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
 }
+/**
+ * Whether a middleware rewrite (`ctx.rewrite()` / `next(payload)`) issued while
+ * rendering the error page dead-ended in another empty reroutable (404/500)
+ * response. The rewrite swaps the state's routeData away from the error route,
+ * so returning that render as-is would produce a blank page; the error handler
+ * should instead retry rendering the error page without middleware.
+ *
+ * @param skipMiddleware Whether middleware was already skipped for this render.
+ * @param errorRouteData The error route matched before middleware ran.
+ * @param renderedRouteData The route data on the state after middleware ran.
+ * @param response The response produced by the middleware-driven render.
+ */
+export declare function rewroteToEmptyErrorResponse(skipMiddleware: boolean, errorRouteData: RouteData, renderedRouteData: RouteData | undefined, response: Response): boolean;

package/dist/core/errors/handler.js

@@ -0,0 +1,7 @@
+import { REROUTABLE_STATUS_CODES } from "../constants.js";
+function rewroteToEmptyErrorResponse(skipMiddleware, errorRouteData, renderedRouteData, response) {
+  return skipMiddleware === false && renderedRouteData !== errorRouteData && response.body === null && REROUTABLE_STATUS_CODES.includes(response.status);
+}
+export {
+  rewroteToEmptyErrorResponse
+};

package/dist/core/logger/load.d.ts

@@ -1,6 +1,10 @@
 import { AstroLogger, type AstroLoggerDestination } from './core.js';
 import type { LoggerHandlerConfig } from './config.js';
 import type { AstroConfig, AstroInlineConfig } from '../../types/public/index.js';
+/**
+ * Loads a logger destination in a Node context, i.e. outside of a built server bundle.
+ * Inside the bundle, the destination comes from the `virtual:astro:logger` module instead.
+ */
 export declare function loadLoggerDestination(config: LoggerHandlerConfig): Promise<AstroLoggerDestination>;
 /**
  * It attempts to load a logger from the entrypoint.

package/dist/core/logger/load.js

@@ -1,64 +1,38 @@
+import { isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
 import { AstroLogger } from "./core.js";
 import { AstroError } from "../errors/index.js";
 import { UnableToLoadLogger } from "../errors/errors-data.js";
-import { default as nodeLoggerCreator, createNodeLoggerFromFlags } from "./impls/node.js";
-import { default as consoleLoggerCreator } from "./impls/console.js";
-import { default as jsonLoggerCreator } from "./impls/json.js";
-import { default as composeLoggerCreator } from "./impls/compose.js";
-function normalizeEntrypoint(entrypoint) {
-  return entrypoint instanceof URL ? entrypoint.href : entrypoint;
+import { createNodeLoggerFromFlags } from "./impls/node.js";
+import {
+  COMPOSE_LOGGER_ENTRYPOINT,
+  normalizeLoggerConfig
+} from "./utils.js";
+async function createDestination(config) {
+  const specifier = isAbsolute(config.entrypoint) ? pathToFileURL(config.entrypoint).href : config.entrypoint;
+  const logger = await import(
+    /* @vite-ignore */
+    specifier
+  );
+  if (config.entrypoint === COMPOSE_LOGGER_ENTRYPOINT) {
+    return logger.default(await Promise.all((config.loggers ?? []).map(createDestination)));
+  }
+  return logger.default(config.config);
 }
 async function loadLoggerDestination(config) {
-  let cause = void 0;
-  const entrypoint = normalizeEntrypoint(config.entrypoint);
+  const normalized = normalizeLoggerConfig(config);
   try {
-    switch (config.entrypoint) {
-      case "astro/logger/node": {
-        return nodeLoggerCreator(config.config);
-      }
-      case "astro/logger/console": {
-        return consoleLoggerCreator(config.config);
-      }
-      case "astro/logger/json": {
-        return jsonLoggerCreator(config.config);
-      }
-      case "astro/logger/compose": {
-        let destinations = [];
-        if (config.config?.loggers) {
-          const loggers = config.config?.loggers;
-          destinations = await Promise.all(
-            loggers.map(async (loggerConfig) => {
-              const logger = await import(
-                /* @vite-ignore */
-                normalizeEntrypoint(loggerConfig.entrypoint)
-              );
-              return logger.default(loggerConfig.config);
-            })
-          );
-        }
-        return composeLoggerCreator(destinations);
-      }
-      default: {
-        const logger = await import(
-          /* @vite-ignore */
-          entrypoint
-        );
-        return logger.default(config.config);
-      }
-    }
+    return await createDestination(normalized);
   } catch (e) {
+    const error = new AstroError({
+      ...UnableToLoadLogger,
+      message: UnableToLoadLogger.message(normalized.entrypoint)
+    });
     if (e instanceof Error) {
-      cause = e;
+      error.cause = e;
     }
+    throw error;
   }
-  const error = new AstroError({
-    ...UnableToLoadLogger,
-    message: UnableToLoadLogger.message(entrypoint)
-  });
-  if (cause) {
-    error.cause = cause;
-  }
-  throw error;
 }
 async function loadOrCreateNodeLogger(astroConfig, inlineAstroConfig) {
   if (inlineAstroConfig._logger) return inlineAstroConfig._logger;

package/dist/core/logger/utils.d.ts

@@ -0,0 +1,21 @@
+import type { LoggerHandlerConfig } from './config.js';
+export declare const COMPOSE_LOGGER_ENTRYPOINT = "astro/logger/compose";
+export interface NormalizedLoggerConfig {
+    /** An absolute file path or a package specifier */
+    entrypoint: string;
+    /** Serializable options passed to the handler factory */
+    config?: Record<string, any> | undefined;
+    /** The composed handlers. Only set for `astro/logger/compose` */
+    loggers?: NormalizedLoggerConfig[];
+}
+/**
+ * Normalizes a user-provided logger config by turning its `entrypoint` into a string that
+ * can be resolved as-is, either by Vite (see `vitePluginLogger`) or by Node
+ * (see `loadLoggerDestination`), and by applying the same treatment to the handlers
+ * composed through `astro/logger/compose`.
+ *
+ * Concretely, a `URL` entrypoint becomes an absolute file path — mirroring what session
+ * drivers do, since both Vite and `import()` can handle those — while a string entrypoint,
+ * e.g. a package specifier, is left untouched.
+ */
+export declare function normalizeLoggerConfig(logger: LoggerHandlerConfig): NormalizedLoggerConfig;

package/dist/core/logger/utils.js

@@ -0,0 +1,20 @@
+import { fileURLToPath } from "node:url";
+const COMPOSE_LOGGER_ENTRYPOINT = "astro/logger/compose";
+function normalizeLoggerConfig(logger) {
+  const entrypoint = normalizeEntrypoint(logger.entrypoint);
+  if (entrypoint === COMPOSE_LOGGER_ENTRYPOINT) {
+    const loggers = logger.config?.loggers ?? [];
+    return {
+      entrypoint,
+      loggers: loggers.map((nested) => normalizeLoggerConfig(nested))
+    };
+  }
+  return { entrypoint, config: logger.config };
+}
+function normalizeEntrypoint(entrypoint) {
+  return entrypoint instanceof URL ? fileURLToPath(entrypoint) : entrypoint;
+}
+export {
+  COMPOSE_LOGGER_ENTRYPOINT,
+  normalizeLoggerConfig
+};

package/dist/core/logger/vite-plugin.d.ts

@@ -0,0 +1,30 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { AstroSettings } from '../../types/astro.js';
+import { type NormalizedLoggerConfig } from './utils.js';
+export declare const VIRTUAL_LOGGER_ID = "virtual:astro:logger";
+/** Resolves an entrypoint to a module id, or `null` if it cannot be resolved. */
+type ResolveEntrypoint = (entrypoint: string) => Promise<string | null>;
+interface EmittedDestination {
+    /** The expression instantiating the destination, e.g. `_logger0({ level: 'info' })` */
+    expression: string;
+    /** The import statements `expression` depends on, in declaration order */
+    imports: string[];
+}
+/**
+ * Emits the source of a logger destination, so that the handler is part of the bundle
+ * rather than imported at runtime from a path that no longer exists once deployed.
+ *
+ * This is the build-time counterpart of `createDestination()` in `./load.ts`: both walk
+ * the same normalized config, but this one *generates code* that instantiates the
+ * destination, while the Node one instantiates it directly through `import()`.
+ */
+export declare function emitDestination(config: NormalizedLoggerConfig, resolveEntrypoint: ResolveEntrypoint, 
+/**
+ * Import names must be unique across the whole virtual module, so nested
+ * destinations continue numbering where their parent left off.
+ */
+nameOffset?: number): Promise<EmittedDestination>;
+export declare function vitePluginLogger({ settings, }: {
+    settings: AstroSettings;
+}): VitePlugin | undefined;
+export {};

package/dist/core/logger/vite-plugin.js

@@ -0,0 +1,79 @@
+import { fileURLToPath } from "node:url";
+import { UnableToLoadLogger } from "../errors/errors-data.js";
+import { AstroError } from "../errors/index.js";
+import { normalizeLoggerConfig } from "./utils.js";
+const VIRTUAL_LOGGER_ID = "virtual:astro:logger";
+const RESOLVED_VIRTUAL_LOGGER_ID = "\0" + VIRTUAL_LOGGER_ID;
+async function emitDestination(config, resolveEntrypoint, nameOffset = 0) {
+  let resolved = null;
+  let cause;
+  try {
+    resolved = await resolveEntrypoint(config.entrypoint);
+  } catch (e) {
+    cause = e;
+  }
+  if (!resolved) {
+    const error = new AstroError({
+      ...UnableToLoadLogger,
+      message: UnableToLoadLogger.message(config.entrypoint)
+    });
+    if (cause instanceof Error) {
+      error.cause = cause;
+    }
+    throw error;
+  }
+  const name = `_logger${nameOffset}`;
+  const imports = [`import ${name} from ${JSON.stringify(resolved)};`];
+  if (config.loggers) {
+    const expressions = [];
+    for (const nested of config.loggers) {
+      const emitted = await emitDestination(nested, resolveEntrypoint, nameOffset + imports.length);
+      imports.push(...emitted.imports);
+      expressions.push(emitted.expression);
+    }
+    return { expression: `${name}([${expressions.join(", ")}])`, imports };
+  }
+  return { expression: `${name}(${JSON.stringify(config.config) ?? "undefined"})`, imports };
+}
+function vitePluginLogger({
+  settings
+}) {
+  const loggerConfig = settings.config.logger;
+  if (!loggerConfig) {
+    return;
+  }
+  return {
+    name: VIRTUAL_LOGGER_ID,
+    enforce: "pre",
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${VIRTUAL_LOGGER_ID}$`)
+      },
+      handler() {
+        return RESOLVED_VIRTUAL_LOGGER_ID;
+      }
+    },
+    load: {
+      filter: {
+        id: new RegExp(`^${RESOLVED_VIRTUAL_LOGGER_ID}$`)
+      },
+      async handler() {
+        const importerPath = fileURLToPath(new URL("package.json", settings.config.root));
+        const { expression, imports } = await emitDestination(
+          normalizeLoggerConfig(loggerConfig),
+          async (entrypoint) => (await this.resolve(entrypoint, importerPath))?.id ?? null
+        );
+        return {
+          code: `${imports.join("\n")}
+export default ${expression};
+`
+        };
+      }
+    }
+  };
+}
+export {
+  VIRTUAL_LOGGER_ID,
+  emitDestination,
+  vitePluginLogger
+};

package/dist/core/messages/runtime.js

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

package/dist/core/routing/handler.js

@@ -93,6 +93,7 @@ class AstroHandler {
     const defaultStatus = this.#app.getDefaultStatusCode(routeData, pathname);
     state.status = defaultStatus;
     let response;
+    let finalizeError;
     try {
       const sessionP = this.#hasSession ? provideSession(state) : void 0;
       const cacheP = provideCache(state);
@@ -143,8 +144,21 @@ class AstroHandler {
         pathname: state.pathname
       });
     } finally {
-      const finalize = state.finalizeAll();
-      if (finalize) await finalize;
+      try {
+        const finalize = state.finalizeAll();
+        if (finalize) await finalize;
+      } catch (err) {
+        finalizeError = err;
+        this.#app.logger.error(null, err.stack || err.message || String(err));
+      }
+    }
+    if (finalizeError) {
+      return this.#app.renderError(request, {
+        ...state.renderOptions,
+        status: 500,
+        error: finalizeError,
+        pathname: state.pathname
+      });
     }
     if (REROUTABLE_STATUS_CODES.includes(response.status) && // If the body isn't null, that means the user sets the 404 status
     // but uses the current route to handle the 404

package/dist/core/session/drivers.d.ts

@@ -1,7 +1,7 @@
 import type { SessionDriverConfig } from './types.js';
 export declare const sessionDrivers: {
-    http: (config?: import("unstorage/drivers/http").HTTPOptions | undefined) => SessionDriverConfig;
     fs: (config?: import("unstorage/drivers/fs").FSStorageOptions | undefined) => SessionDriverConfig;
+    http: (config?: import("unstorage/drivers/http").HTTPOptions | undefined) => SessionDriverConfig;
     azureAppConfiguration: (config?: import("unstorage/drivers/azure-app-configuration").AzureAppConfigurationOptions | undefined) => SessionDriverConfig;
     azureCosmos: (config?: import("unstorage/drivers/azure-cosmos").AzureCosmosOptions | undefined) => SessionDriverConfig;
     azureKeyVault: (config?: import("unstorage/drivers/azure-key-vault").AzureKeyVaultOptions | undefined) => SessionDriverConfig;

package/dist/core/session/handler.js

@@ -20,7 +20,8 @@ async function provideSessionAsync(state, config) {
         config,
         runtimeMode: pipeline.runtimeMode,
         driverFactory,
-        mockStorage: null
+        mockStorage: null,
+        logger: pipeline.logger
       });
     },
     finalize(session) {

package/dist/core/session/runtime.d.ts

@@ -1,18 +1,21 @@
 import type { RuntimeMode } from '../../types/public/config.js';
 import type { AstroCookies } from '../cookies/cookies.js';
+import type { AstroLogger } from '../logger/core.js';
 import type { SessionDriverFactory } from './types.js';
 import type { SSRManifestSession } from '../app/types.js';
 import { type Storage } from 'unstorage';
 export declare const PERSIST_SYMBOL: unique symbol;
+export interface AstroSessionOptions {
+    cookies: AstroCookies;
+    config: SSRManifestSession | undefined;
+    runtimeMode: RuntimeMode;
+    driverFactory: SessionDriverFactory | null;
+    mockStorage: Storage | null;
+    logger: AstroLogger;
+}
 export declare class AstroSession {
     #private;
-    constructor({ cookies, config, runtimeMode, driverFactory, mockStorage, }: {
-        cookies: AstroCookies;
-        config: SSRManifestSession | undefined;
-        runtimeMode: RuntimeMode;
-        driverFactory: SessionDriverFactory | null;
-        mockStorage: Storage | null;
-    });
+    constructor({ cookies, config, runtimeMode, driverFactory, mockStorage, logger, }: AstroSessionOptions);
     /**
      * Gets a session value. Returns `undefined` if the session or value does not exist.
      */

package/dist/core/session/runtime.js

@@ -46,7 +46,7 @@ class AstroSession {
   // When we load the data from storage, we need to merge it with the local partial data,
   // preserving in-memory changes and deletions.
   #partial = true;
-  // The driver factory function provided by the pipeline
+  #logger;
   #driverFactory;
   static #sharedStorage = /* @__PURE__ */ new Map();
   constructor({
@@ -54,8 +54,10 @@ class AstroSession {
     config,
     runtimeMode,
     driverFactory,
-    mockStorage
+    mockStorage,
+    logger
   }) {
+    this.#logger = logger;
     if (!config) {
       throw new AstroError({
         ...SessionStorageInitError,
@@ -185,7 +187,8 @@ class AstroSession {
     try {
       data = await this.#ensureData();
     } catch (err) {
-      console.error("Failed to load session data during regeneration:", err);
+      this.#logger.error("session", `Failed to load session data during regeneration: ${err}`);
+      this.#partial = false;
     }
     const oldSessionId = this.#sessionID;
     this.#sessionID = crypto.randomUUID();
@@ -195,7 +198,7 @@ class AstroSession {
     await this.#setCookie();
     if (oldSessionId && this.#storage) {
       this.#storage.removeItem(oldSessionId).catch((err) => {
-        console.error("Failed to remove old session data:", err);
+        this.#logger.error("session", `Failed to remove old session ${oldSessionId}: ${err}`);
       });
     }
   }
@@ -232,7 +235,7 @@ class AstroSession {
     if (this.#toDestroy.size > 0) {
       const cleanupPromises = [...this.#toDestroy].map(
         (sessionId) => storage.removeItem(sessionId).catch((err) => {
-          console.error("Failed to clean up session %s:", sessionId, err);
+          this.#logger.error("session", `Failed to remove session ${sessionId}: ${err}`);
         })
       );
       await Promise.all(cleanupPromises);
@@ -296,7 +299,7 @@ class AstroSession {
     try {
       const storedMap = unflatten(raw);
       if (!(storedMap instanceof Map)) {
-        await this.destroy();
+        this.destroy();
         throw new AstroError({
           ...SessionStorageInitError,
           message: SessionStorageInitError.message(
@@ -315,7 +318,7 @@ class AstroSession {
       this.#partial = false;
       return this.#data;
     } catch (err) {
-      await this.destroy();
+      this.destroy();
       if (err instanceof AstroError) {
         throw err;
       }

package/dist/manifest/serialized.js

@@ -20,6 +20,7 @@ import { MIDDLEWARE_MODULE_ID } from "../core/middleware/vite-plugin.js";
 import { SERVER_ISLAND_MANIFEST } from "../core/server-islands/vite-plugin-server-islands.js";
 import { VIRTUAL_CACHE_PROVIDER_ID } from "../core/cache/vite-plugin.js";
 import { VIRTUAL_SESSION_DRIVER_ID } from "../core/session/vite-plugin.js";
+import { VIRTUAL_LOGGER_ID } from "../core/logger/vite-plugin.js";
 import { VIRTUAL_PAGES_MODULE_ID } from "../vite-plugin-pages/index.js";
 import { ASTRO_RENDERERS_MODULE_ID } from "../vite-plugin-renderers/index.js";
 import { ASTRO_ROUTES_MODULE_ID } from "../vite-plugin-routes/index.js";
@@ -86,6 +87,7 @@ function serializedManifestPlugin({
         }
         const hasCacheConfig = !!settings.config.cache?.provider;
         const cacheProviderLine = hasCacheConfig ? `cacheProvider: () => import('${VIRTUAL_CACHE_PROVIDER_ID}'),` : "";
+        const loggerLine = settings.config.logger ? `logger: () => import('${VIRTUAL_LOGGER_ID}'),` : "";
         const code = `
 					import { deserializeManifest as _deserializeManifest } from 'astro/app';
 					import { renderers } from '${ASTRO_RENDERERS_MODULE_ID}';
@@ -106,6 +108,7 @@ function serializedManifestPlugin({
 					  middleware: () => import('${MIDDLEWARE_MODULE_ID}'),
 					  sessionDriver: () => import('${VIRTUAL_SESSION_DRIVER_ID}'),
 					  ${cacheProviderLine}
+					  ${loggerLine}
 					  serverIslandMappings: () => import('${SERVER_ISLAND_MANIFEST}'),
 					  routes: manifestRoutes,
 					  pageMap,
@@ -157,10 +160,6 @@ async function createSerializedManifest(settings, encodedKey) {
       styleDirective
     };
   }
-  let loggerConfig = void 0;
-  if (settings.config.logger) {
-    loggerConfig = settings.config.logger;
-  }
   return {
     rootDir: settings.config.root.toString(),
     srcDir: settings.config.srcDir.toString(),
@@ -210,8 +209,7 @@ async function createSerializedManifest(settings, encodedKey) {
       placement: settings.config.devToolbar.placement
     },
     logLevel: settings.logLevel,
-    shouldInjectCspMetaTags: false,
-    loggerConfig
+    shouldInjectCspMetaTags: false
   };
 }
 export {

package/dist/types/public/config.d.ts

@@ -1516,8 +1516,7 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
      *
      * By default, Astro uses a built-in logger that outputs human-friendly logs to the console. You can customize this behavior by providing [your own logger handler](https://docs.astro.build/en/reference/logger-reference/#custom-loggers) or by using one of the [built-in log handlers](https://docs.astro.build/en/reference/logger-reference/#built-in-loggers):
      *
-     * ```js
-     * // astro.config.mjs
+     * ```js title="astro.config.mjs"
      * import { defineConfig, logHandlers } from 'astro/config';
      *
      * export default defineConfig({
@@ -1535,7 +1534,8 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
      * @version 7.0.0
      * @description
      *
-     * The entrypoint of the log handler. This can be a path to a file in your project or an npm package:
+     * The entrypoint for the [logger implementation](https://docs.astro.build/en/reference/logger-reference/#the-logger-implementation).
+     * This can be an npm package, or a `URL` pointing to a file in your project:
      *
      * ```js title="astro.config.mjs"
      * import { defineConfig } from 'astro/config';