astro 7.1.4 → 7.1.5

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "7.1.4";
+  version = "7.1.5";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/container/index.js

@@ -65,8 +65,7 @@ function createManifest(manifest, renderers, middleware) {
       debugInfoOutput: "",
       placement: void 0
     },
-    logLevel: "silent",
-    loggerConfig: manifest?.loggerConfig ?? void 0
+    logLevel: "silent"
   };
 }
 class experimental_AstroContainer {

package/dist/content/content-layer.js

@@ -196,7 +196,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "7.1.4") {
+    if (previousAstroVersion && previousAstroVersion !== "7.1.5") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -204,8 +204,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("7.1.4") {
-      this.#store.metaStore().set("astro-version", "7.1.4");
+    if ("7.1.5") {
+      this.#store.metaStore().set("astro-version", "7.1.5");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/core/app/types.d.ts

@@ -12,7 +12,6 @@ import type { BaseSessionConfig, SessionDriverFactory } from '../session/types.j
 import type { DevToolbarPlacement } from '../../types/public/toolbar.js';
 import type { MiddlewareMode } from '../../types/public/integrations.js';
 import type { BaseApp } from './base.js';
-import type { LoggerHandlerConfig } from '../logger/config.js';
 type ComponentPath = string;
 export type StylesheetAsset = {
     type: 'inline';
@@ -138,7 +137,6 @@ export type SSRManifest = {
     };
     internalFetchHeaders?: Record<string, string>;
     logLevel: AstroLoggerLevel;
-    loggerConfig: LoggerHandlerConfig | undefined;
 };
 export type SSRActions = {
     server: Record<string, ActionClient<any, any, any>>;

package/dist/core/base-pipeline.js

@@ -11,7 +11,6 @@ import { createDefaultRoutes } from "./routing/default.js";
 import { ensure404Route } from "./routing/astro-designed-error-pages.js";
 import { Router } from "./routing/router.js";
 import { FORBIDDEN_PATH_KEYS } from "@astrojs/internal-helpers/object";
-import { loadLoggerDestination } from "./logger/load.js";
 const PipelineFeatures = {
   redirects: 1 << 0,
   sessions: 1 << 1,
@@ -171,9 +170,10 @@ class Pipeline {
       return this.logger;
     }
     this.resolvedLogger = true;
-    if (this.manifest.loggerConfig) {
+    const destination = (await this.manifest.logger?.())?.default;
+    if (destination) {
       this.logger = new AstroLogger({
-        destination: await loadLoggerDestination(this.manifest.loggerConfig),
+        destination,
         level: this.manifest.logLevel
       });
     }
@@ -231,6 +231,12 @@ class Pipeline {
       );
     }
     for (const key of pathKeys) {
+      if (typeof server === "function") {
+        throw new AstroError({
+          ...ActionNotFoundError,
+          message: ActionNotFoundError.message(pathKeys.join("."))
+        });
+      }
       if (FORBIDDEN_PATH_KEYS.has(key)) {
         throw new AstroError({
           ...ActionNotFoundError,

package/dist/core/build/plugins/plugin-manifest.js

@@ -236,10 +236,6 @@ async function buildManifest(opts, internals, staticFiles, encodedKey) {
     }
   }
   const middlewareMode = resolveMiddlewareMode(opts.settings.adapter?.adapterFeatures);
-  let loggerConfig = void 0;
-  if (settings.config.logger) {
-    loggerConfig = settings.config.logger;
-  }
   return {
     rootDir: opts.settings.config.root.toString(),
     cacheDir: opts.settings.config.cacheDir.toString(),
@@ -288,8 +284,7 @@ async function buildManifest(opts, internals, staticFiles, encodedKey) {
     },
     internalFetchHeaders,
     logLevel: settings.logLevel,
-    shouldInjectCspMetaTags: shouldTrackCspHashes(settings.config.security.csp),
-    loggerConfig
+    shouldInjectCspMetaTags: shouldTrackCspHashes(settings.config.security.csp)
   };
 }
 export {

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "7.1.4";
+const ASTRO_VERSION = "7.1.5";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const ASTRO_ERROR_HEADER = "X-Astro-Error";
 const DEFAULT_404_COMPONENT = "astro-default-404.astro";

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/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.4";
+  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.4"}`
+        `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/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';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "7.1.4",
+  "version": "7.1.5",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -119,7 +119,7 @@
     "github-slugger": "^2.0.0",
     "html-escaper": "3.0.3",
     "http-cache-semantics": "^4.2.0",
-    "js-yaml": "^4.1.1",
+    "js-yaml": "^4.3.0",
     "jsonc-parser": "^3.3.1",
     "magic-string": "^1.0.0",
     "magicast": "^0.5.2",
@@ -146,15 +146,15 @@
     "xxhash-wasm": "^1.1.0",
     "yargs-parser": "^22.0.0",
     "zod": "^4.3.6",
-    "@astrojs/internal-helpers": "0.10.1",
-    "@astrojs/markdown-satteri": "0.3.4",
+    "@astrojs/internal-helpers": "0.10.2",
+    "@astrojs/markdown-satteri": "0.3.5",
     "@astrojs/telemetry": "3.3.3"
   },
   "optionalDependencies": {
     "sharp": "^0.34.0 || ^0.35.0"
   },
   "peerDependencies": {
-    "@astrojs/markdown-remark": "7.2.1"
+    "@astrojs/markdown-remark": "7.2.2"
   },
   "peerDependenciesMeta": {
     "@astrojs/markdown-remark": {
@@ -187,7 +187,7 @@
     "undici": "^7.22.0",
     "vitest": "^4.1.0",
     "@astrojs/check": "0.9.10",
-    "@astrojs/markdown-remark": "7.2.1",
+    "@astrojs/markdown-remark": "7.2.2",
     "astro-scripts": "0.0.14"
   },
   "engines": {