astro 7.2.10 → 7.3.0

package/dist/core/app/entrypoints/index.js

@@ -12,27 +12,29 @@ import {
   serializeRouteInfo
 } from "../manifest.js";
 import {
-  beginContentEntryCollection,
-  endContentEntryCollection
-} from "../../build/incremental-content-collector.js";
+  getInstalledRenderScope,
+  installRenderScope
+} from "../../render-scope/scope.js";
+import { recordStaticImage } from "../../render-scope/record.js";
 import {
-  beginImageCollection,
-  endImageCollection,
-  recordStaticImage
-} from "../../build/incremental-image-collector.js";
+  collectPrerenderMetadata
+} from "../../render-scope/collect.js";
+import {
+  renderForPrerender
+} from "../prerender.js";
 export {
   App,
   BaseApp,
-  beginContentEntryCollection,
-  beginImageCollection,
+  collectPrerenderMetadata,
   createConsoleLogger,
   deserializeManifest,
   deserializeRouteData,
   deserializeRouteInfo,
-  endContentEntryCollection,
-  endImageCollection,
   fromRoutingStrategy,
+  getInstalledRenderScope,
+  installRenderScope,
   recordStaticImage,
+  renderForPrerender,
   serializeRouteData,
   serializeRouteInfo,
   toRoutingStrategy

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

@@ -0,0 +1,32 @@
+import type { PrerenderResult } from '../../types/public/integrations.js';
+import type { RouteData } from '../../types/public/internal.js';
+import type { AstroLogger } from '../logger/core.js';
+export interface PrerenderableApp {
+    logger: AstroLogger;
+    render(request: Request, opts: {
+        routeData?: RouteData;
+    }): Promise<Response>;
+}
+export interface PrerenderRenderOptions {
+    routeData?: RouteData;
+    /** Collect per-render incremental metadata and return it on the result. Default false. */
+    collectMetadata?: boolean;
+}
+/**
+ * Renders a single prerendered path through `app.render`, optionally collecting
+ * the per-render incremental metadata (content entries rendered, image
+ * transforms resolved) and returning it by value on the result.
+ *
+ * When not collecting, this short-circuits to a bare `app.render` — the
+ * response is the app's own, unbuffered. When collecting, the response body is
+ * fully buffered *inside* the render scope so lazily-driven rendering work
+ * records before the metadata snapshot; the returned response is a
+ * reconstruction carrying the buffered body with status/statusText/headers and
+ * body-nullness preserved.
+ *
+ * This function performs no scope installation; installing a render scope for
+ * the rendering runtime is the caller's responsibility. When collection is
+ * requested but no scope is installed, `metadata` is `undefined`
+ * ("not tracked").
+ */
+export declare function renderForPrerender(app: PrerenderableApp, request: Request, options?: PrerenderRenderOptions): Promise<PrerenderResult>;

package/dist/core/app/prerender.js

@@ -0,0 +1,22 @@
+import { collectPrerenderMetadata } from "../render-scope/collect.js";
+const NULL_BODY_STATUSES = [101, 204, 205, 304];
+async function renderForPrerender(app, request, options) {
+  const routeData = options?.routeData;
+  if (!options?.collectMetadata) {
+    return { response: await app.render(request, { routeData }) };
+  }
+  const { value: response, metadata } = await collectPrerenderMetadata(async () => {
+    const rendered = await app.render(request, { routeData });
+    const bytes = rendered.body === null ? null : await rendered.arrayBuffer();
+    const nullBody = bytes === null || NULL_BODY_STATUSES.includes(rendered.status);
+    return new Response(nullBody ? null : bytes, {
+      status: rendered.status,
+      statusText: rendered.statusText,
+      headers: rendered.headers
+    });
+  }, app.logger);
+  return { response, metadata };
+}
+export {
+  renderForPrerender
+};

package/dist/core/build/default-prerenderer.js

@@ -1,3 +1,5 @@
+import { renderForPrerender } from "../app/prerender.js";
+import { ensureAsyncRenderScope } from "../render-scope/node-scope.js";
 import { StaticPaths } from "../../runtime/prerender/static-paths.js";
 function createDefaultPrerenderer({
   internals,
@@ -24,8 +26,9 @@ function createDefaultPrerenderer({
       const staticPaths = new StaticPaths(prerenderer.app);
       return staticPaths.getAll();
     },
-    async render(request, { routeData }) {
-      return prerenderer.app.render(request, { routeData });
+    async render(request, { routeData, collectMetadata }) {
+      if (collectMetadata) ensureAsyncRenderScope();
+      return renderForPrerender(prerenderer.app, request, { routeData, collectMetadata });
     },
     async teardown() {
     }

package/dist/core/build/generate.d.ts

@@ -23,6 +23,8 @@ interface RenderToPathPayload {
     options: StaticBuildOptions;
     routeToHeaders?: RouteToHeaders;
     logger: AstroLogger;
+    /** Ask the prerenderer to collect and report per-render incremental metadata. */
+    collectMetadata?: boolean;
 }
 /**
  * Renders a single prerendered path to an in-memory result.
@@ -48,5 +50,5 @@ interface RenderToPathPayload {
  *                                not need to inspect the headers after the call can omit this.
  * @param params.logger         - Logger instance.
  */
-export declare function renderPath({ prerenderer, pathname, route, options, routeToHeaders, logger, }: RenderToPathPayload): Promise<RenderPathResult | null>;
+export declare function renderPath({ prerenderer, pathname, route, options, routeToHeaders, logger, collectMetadata, }: RenderToPathPayload): Promise<RenderPathResult | null>;
 export {};

package/dist/core/build/generate.js

@@ -29,11 +29,6 @@ import { routeIsRedirect } from "../routing/helpers.js";
 import { getOutputFilename } from "../output-filename.js";
 import { getOutFile, getOutFolder } from "./common.js";
 import { createDefaultPrerenderer } from "./default-prerenderer.js";
-import {
-  beginContentEntryCollection,
-  endContentEntryCollection
-} from "./incremental-content-collector.js";
-import { beginImageCollection, endImageCollection } from "./incremental-image-collector.js";
 import { IncrementalBuildCache } from "./incremental.js";
 import { computeConfigHash } from "./config-hash/index.js";
 import { computeLockfileHash } from "./lockfile/index.js";
@@ -76,26 +71,19 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
   let staticImageList = getStaticImageList();
   let cache = null;
   if (options.settings.config.experimental.incrementalBuild) {
-    if (options.settings.config.build.concurrency > 1) {
-      logger.warn(
-        "build",
-        "The incremental build cache is disabled because `build.concurrency` is greater than 1."
-      );
-    } else {
-      const [configHash, lockfileHash, keyDigest] = await Promise.all([
-        computeConfigHash(options.settings.config),
-        computeLockfileHash(fileURLToPath(options.settings.config.root)),
-        options.key.then(hashCryptoKey)
-      ]);
-      cache = IncrementalBuildCache.load(
-        options.settings,
-        configHash,
-        lockfileHash,
-        keyDigest,
-        internals.contentEntryRenderHashes ?? /* @__PURE__ */ new Map(),
-        options.force
-      );
-    }
+    const [configHash, lockfileHash, keyDigest] = await Promise.all([
+      computeConfigHash(options.settings.config),
+      computeLockfileHash(fileURLToPath(options.settings.config.root)),
+      options.key.then(hashCryptoKey)
+    ]);
+    cache = IncrementalBuildCache.load(
+      options.settings,
+      configHash,
+      lockfileHash,
+      keyDigest,
+      internals.contentEntryRenderHashes ?? /* @__PURE__ */ new Map(),
+      options.force
+    );
   }
   try {
     const pathsWithRoutes = await prerenderer.getStaticPaths();
@@ -277,7 +265,8 @@ async function renderPath({
   route,
   options,
   routeToHeaders = /* @__PURE__ */ new Map(),
-  logger
+  logger,
+  collectMetadata
 }) {
   const { config } = options.settings;
   if (route.type === "fallback" && route.pathname !== "/") {
@@ -318,7 +307,7 @@ async function renderPath({
   let metadata;
   try {
     const rendered = normalizePrerenderResult(
-      await prerenderer.render(request, { routeData: route })
+      await prerenderer.render(request, { routeData: route, collectMetadata })
     );
     response = rendered.response;
     metadata = rendered.metadata;
@@ -425,22 +414,17 @@ async function generatePathWithPrerenderer(prerenderer, pathname, route, options
   if (route.type === "page") {
     addPageName(pathname, options);
   }
-  if (cache) {
-    beginContentEntryCollection();
-    beginImageCollection();
-  }
   const result = await renderPath({
     prerenderer,
     pathname,
     route,
     options,
     routeToHeaders,
-    logger
+    logger,
+    collectMetadata: cache !== null
   });
-  const collectedContentEntryKeys = cache ? endContentEntryCollection() : void 0;
-  const collectedStaticImages = cache ? endImageCollection() : void 0;
-  const contentEntryKeys = result?.metadata?.contentEntryKeys ?? collectedContentEntryKeys;
-  const staticImages = result?.metadata?.staticImages ?? collectedStaticImages;
+  const contentEntryKeys = result?.metadata?.contentEntryKeys;
+  const staticImages = result?.metadata?.staticImages;
   const headers = cache ? [...routeToHeaders.get(pathname)?.headers ?? []] : void 0;
   if (!result) {
     logRenderTime(logger, timeStart, true);
@@ -448,7 +432,7 @@ async function generatePathWithPrerenderer(prerenderer, pathname, route, options
   }
   await nodeFs.promises.mkdir(result.outFolder, { recursive: true });
   await nodeFs.promises.writeFile(result.outFile, result.body);
-  if (cache && cacheKey !== void 0) {
+  if (cache && cacheKey !== void 0 && result.metadata !== void 0) {
     await cache.writeOutputFile(options.settings, relativeOutFile, result.body);
     cache.record(
       route.component,

package/dist/core/cache/handler.js

@@ -52,7 +52,18 @@ async function handleCache(state, next) {
       {
         request: state.request,
         url: new URL(state.request.url),
-        waitUntil: state.renderOptions.waitUntil
+        waitUntil: state.renderOptions.waitUntil,
+        logger: {
+          info(msg) {
+            state.logger.info("cache", msg);
+          },
+          warn(msg) {
+            state.logger.warn("cache", msg);
+          },
+          error(msg) {
+            state.logger.error("cache", msg);
+          }
+        }
       },
       async () => {
         const res = await next();

package/dist/core/cache/memory-provider.js

@@ -89,7 +89,17 @@ function getPathFromCacheKey(key, queryConfig) {
   const url = new URL(urlPart);
   return `${url.pathname}${buildQueryString(url, queryConfig)}`;
 }
-const IGNORED_VARY_HEADERS = /* @__PURE__ */ new Set(["cookie", "set-cookie"]);
+const IGNORED_VARY_HEADERS = /* @__PURE__ */ new Set(["set-cookie"]);
+function getUncacheableVaryHeader(response) {
+  const vary = response.headers.get("Vary");
+  if (!vary) return void 0;
+  for (const header of vary.split(",")) {
+    const normalized = header.trim().toLowerCase();
+    if (normalized === "cookie") return "Cookie";
+    if (normalized === "*") return "*";
+  }
+  return void 0;
+}
 function parseVaryHeader(response) {
   const vary = response.headers.get("Vary");
   if (!vary || vary.trim() === "*") return void 0;
@@ -118,9 +128,14 @@ function hasSetCookieHeader(response) {
   if (response.headers.has("set-cookie")) return true;
   return hasAtLeastOneCookie(getCookiesFromResponse(response));
 }
-function warnSkippedSetCookie(url) {
-  console.warn(
-    `[astro:cache] Skipping cache for ${url.pathname}${url.search} because response includes Set-Cookie.`
+function warnSkippedSetCookie(logger, url) {
+  logger.warn(
+    `Skipping cache for ${url.pathname}${url.search} because response includes Set-Cookie.`
+  );
+}
+function warnSkippedVary(logger, url, header) {
+  logger.warn(
+    `Skipping cache for ${url.pathname}${url.search} because response includes Vary: ${header}.`
   );
 }
 class LRUMap {
@@ -232,7 +247,13 @@ const memoryProvider = ((config) => {
               const { maxAge: newMaxAge, swr: newSwr } = parseCdnCacheControl(cdnCC2);
               if (newMaxAge > 0) {
                 if (hasSetCookieHeader(freshResponse)) {
-                  warnSkippedSetCookie(requestUrl);
+                  warnSkippedSetCookie(context.logger, requestUrl);
+                  return;
+                }
+                const uncacheableVary = getUncacheableVaryHeader(freshResponse);
+                if (uncacheableVary) {
+                  cache.delete(key);
+                  warnSkippedVary(context.logger, requestUrl, uncacheableVary);
                   return;
                 }
                 const newTags = parseCacheTags(freshResponse.headers.get("Cache-Tag"));
@@ -249,8 +270,8 @@ const memoryProvider = ((config) => {
                 cache.set(key, newEntry);
               }
             }).catch((error) => {
-              console.warn(
-                `[astro:cache] Background revalidation failed for ${requestUrl.pathname}${requestUrl.search}: ${String(
+              context.logger.warn(
+                `Background revalidation failed for ${requestUrl.pathname}${requestUrl.search}: ${String(
                   error
                 )}`
               );
@@ -266,7 +287,13 @@ const memoryProvider = ((config) => {
       const { maxAge, swr } = parseCdnCacheControl(cdnCC);
       if (maxAge > 0) {
         if (hasSetCookieHeader(response)) {
-          warnSkippedSetCookie(requestUrl);
+          warnSkippedSetCookie(context.logger, requestUrl);
+          return response;
+        }
+        const uncacheableVary = getUncacheableVaryHeader(response);
+        if (uncacheableVary) {
+          cache.delete(key);
+          warnSkippedVary(context.logger, requestUrl, uncacheableVary);
           return response;
         }
         const tags = parseCacheTags(response.headers.get("Cache-Tag"));

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

@@ -1,4 +1,5 @@
 import type { MiddlewareNext } from '../../types/public/common.js';
+import type { AstroRuntimeLogger } from '../../types/public/context.js';
 import type { WaitUntilHook } from '../wait-until.js';
 export interface CacheOptions {
     maxAge?: number;
@@ -27,6 +28,7 @@ export interface CacheProvider {
         request: Request;
         url: URL;
         waitUntil?: WaitUntilHook;
+        logger: AstroRuntimeLogger;
     }, next: MiddlewareNext): Promise<Response>;
     invalidate(options: InvalidateOptions): Promise<void>;
 }

package/dist/core/config/schemas/base.d.ts

@@ -34,10 +34,10 @@ export declare const AstroConfigSchema: z.ZodObject<{
         name: z.ZodString;
         hooks: z.ZodDefault<z.ZodObject<{}, z.core.$loose>>;
     }, z.core.$strip>>;
-    integrations: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodObject<{
+    integrations: z.ZodDefault<z.ZodOptional<z.ZodPreprocess<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         hooks: z.ZodDefault<z.ZodObject<{}, z.core.$loose>>;
-    }, z.core.$strip>>>>>;
+    }, z.core.$strip>>, unknown>>>;
     build: z.ZodPrefault<z.ZodObject<{
         format: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"file">, z.ZodLiteral<"directory">, z.ZodLiteral<"preserve">]>>>;
         client: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodTransform<URL, string>>;
@@ -55,13 +55,13 @@ export declare const AstroConfigSchema: z.ZodObject<{
         }>>>;
         concurrency: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     }, z.core.$strip>>;
-    server: z.ZodPrefault<z.ZodPipe<z.ZodTransform<any, unknown>, z.ZodObject<{
+    server: z.ZodPrefault<z.ZodPreprocess<z.ZodObject<{
         open: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>>;
         host: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>>;
         port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         headers: z.ZodOptional<z.ZodCustom<OutgoingHttpHeaders, OutgoingHttpHeaders>>;
         allowedHosts: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<true>]>>>;
-    }, z.core.$strip>>>;
+    }, z.core.$strip>, unknown>>;
     redirects: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         status: z.ZodUnion<readonly [z.ZodLiteral<300>, z.ZodLiteral<301>, z.ZodLiteral<302>, z.ZodLiteral<303>, z.ZodLiteral<304>, z.ZodLiteral<307>, z.ZodLiteral<308>]>;
         destination: z.ZodString;
@@ -456,8 +456,8 @@ export declare const AstroConfigSchema: z.ZodObject<{
         fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
         optimizedFallbacks: z.ZodOptional<z.ZodBoolean>;
         display: z.ZodOptional<z.ZodEnum<{
-            auto: "auto";
             optional: "optional";
+            auto: "auto";
             fallback: "fallback";
             block: "block";
             swap: "swap";

package/dist/core/config/schemas/relative.d.ts

@@ -10,10 +10,10 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         name: z.ZodString;
         hooks: z.ZodDefault<z.ZodObject<{}, z.core.$loose>>;
     }, z.core.$strip>>;
-    integrations: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodObject<{
+    integrations: z.ZodDefault<z.ZodOptional<z.ZodPreprocess<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         hooks: z.ZodDefault<z.ZodObject<{}, z.core.$loose>>;
-    }, z.core.$strip>>>>>;
+    }, z.core.$strip>>, unknown>>>;
     redirects: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         status: z.ZodUnion<readonly [z.ZodLiteral<300>, z.ZodLiteral<301>, z.ZodLiteral<302>, z.ZodLiteral<303>, z.ZodLiteral<304>, z.ZodLiteral<307>, z.ZodLiteral<308>]>;
         destination: z.ZodString;
@@ -408,8 +408,8 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
         optimizedFallbacks: z.ZodOptional<z.ZodBoolean>;
         display: z.ZodOptional<z.ZodEnum<{
-            auto: "auto";
             optional: "optional";
+            auto: "auto";
             fallback: "fallback";
             block: "block";
             swap: "swap";
@@ -472,13 +472,13 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         }>>>;
         concurrency: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     }, z.core.$strip>>>;
-    server: z.ZodPrefault<z.ZodPipe<z.ZodTransform<any, unknown>, z.ZodObject<{
+    server: z.ZodPrefault<z.ZodPreprocess<z.ZodObject<{
         open: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>>;
         host: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>>;
         port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         headers: z.ZodOptional<z.ZodCustom<OutgoingHttpHeaders, OutgoingHttpHeaders>>;
         allowedHosts: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<true>]>>>;
-    }, z.core.$strip>>>;
+    }, z.core.$strip>, unknown>>;
 }, z.core.$strip>, z.ZodTransform<{
     base: string;
     trailingSlash: "never" | "ignore" | "always";
@@ -727,7 +727,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         formats?: ["woff2" | "woff" | "otf" | "ttf" | "eot", ...("woff2" | "woff" | "otf" | "ttf" | "eot")[]] | undefined;
         fallbacks?: string[] | undefined;
         optimizedFallbacks?: boolean | undefined;
-        display?: "auto" | "optional" | "fallback" | "block" | "swap" | undefined;
+        display?: "optional" | "auto" | "fallback" | "block" | "swap" | undefined;
         stretch?: string | undefined;
         featureSettings?: string | undefined;
         variationSettings?: string | undefined;
@@ -994,7 +994,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         formats?: ["woff2" | "woff" | "otf" | "ttf" | "eot", ...("woff2" | "woff" | "otf" | "ttf" | "eot")[]] | undefined;
         fallbacks?: string[] | undefined;
         optimizedFallbacks?: boolean | undefined;
-        display?: "auto" | "optional" | "fallback" | "block" | "swap" | undefined;
+        display?: "optional" | "auto" | "fallback" | "block" | "swap" | undefined;
         stretch?: string | undefined;
         featureSettings?: string | undefined;
         variationSettings?: string | undefined;

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "7.2.10";
+const ASTRO_VERSION = "7.3.0";
 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/cookies/cookies.d.ts

@@ -1,4 +1,5 @@
 import type { SerializeOptions } from 'cookie';
+import type { AstroLogger } from '../logger/core.js';
 export type AstroCookieSetOptions = Pick<SerializeOptions, 'domain' | 'path' | 'expires' | 'maxAge' | 'httpOnly' | 'sameSite' | 'secure' | 'encode' | 'partitioned'>;
 export interface AstroCookieGetOptions {
     decode?: (value: string) => string;
@@ -25,7 +26,7 @@ declare class AstroCookie implements AstroCookieInterface {
 }
 declare class AstroCookies implements AstroCookiesInterface {
     #private;
-    constructor(request: Request);
+    constructor(request: Request, logger: Pick<AstroLogger, 'warn'>);
     /**
      * Astro.cookies.delete(key) is used to delete a cookie. Using this method will result
      * in a Set-Cookie header added to the response.

package/dist/core/cookies/cookies.js

@@ -29,11 +29,13 @@ class AstroCookies {
   #requestValues;
   #outgoing;
   #consumed;
-  constructor(request) {
+  #logger;
+  constructor(request, logger) {
     this.#request = request;
     this.#requestValues = null;
     this.#outgoing = null;
     this.#consumed = false;
+    this.#logger = logger;
   }
   /**
    * Astro.cookies.delete(key) is used to delete a cookie. Using this method will result
@@ -112,11 +114,10 @@ class AstroCookies {
    */
   set(key, value, options) {
     if (this.#consumed) {
-      const warning = new Error(
+      this.#logger.warn(
+        "SKIP_FORMAT",
         "Astro.cookies.set() was called after the cookies had already been sent to the browser.\nThis may have happened if this method was called in an imported component.\nPlease make sure that Astro.cookies.set() is only called in the frontmatter of the main page."
       );
-      warning.name = "Warning";
-      console.warn(warning);
     }
     let serializedValue;
     if (typeof value === "string") {

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.2.10";
+  const currentVersion = "7.3.0";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {
@@ -59,7 +59,7 @@ async function dev(inlineConfig) {
     const chunkSize = getDataStoreChunkSize(restart.container.settings);
     if (chunkSize !== void 0) {
       const dataStoreDir = getDataStoreDir(restart.container.settings, true);
-      store = await MutableDataStore.fromDir(dataStoreDir, chunkSize);
+      store = await MutableDataStore.fromDir(dataStoreDir, chunkSize, logger);
     } else {
       const dataStoreFile = getDataStoreFile(restart.container.settings, true);
       store = await MutableDataStore.fromFile(dataStoreFile);

package/dist/core/fetch/fetch-state.d.ts

@@ -7,7 +7,7 @@ import { AstroCookies } from '../cookies/index.js';
 import type { RenderErrorOptions, ResolvedRenderOptions } from '../app/base.js';
 import type { SSRManifest } from '../app/types.js';
 import { type RequestLogPayload } from '../environment/index.js';
-import type { AstroLogger } from '../logger/core.js';
+import { type AstroLogger } from '../logger/core.js';
 /**
  * Per-render facade inputs passed by `BaseApp.render`'s fast path to the
  * internal `FetchState` constructor and stored as plain state fields.

package/dist/core/fetch/fetch-state.js

@@ -35,6 +35,7 @@ import { getRenderOptions } from "../app/render-options.js";
 import { getFirstForwardedValue, validateForwardedHeaders } from "../app/validate-headers.js";
 import { getEnvironment } from "../environment/index.js";
 import { getLogger } from "../logger/manifest-logger.js";
+import { astroToRuntimeLogger } from "../logger/core.js";
 import { getSite } from "../manifest/derived.js";
 import { getRouteCache } from "../render/route-cache.js";
 import { getRouteTable, matchAllRoutes, matchRoute } from "../routing/route-table.js";
@@ -232,7 +233,7 @@ class FetchState {
     this.clientAddress = options?.clientAddress;
     this.locals = options?.locals ?? {};
     this.url = url;
-    this.cookies = new AstroCookies(request);
+    this.cookies = new AstroCookies(request, this.logger);
     if (manifest.allowedDomains && manifest.allowedDomains.length > 0 && !this.routeData?.prerender) {
       this.#applyForwardedHeaders();
     }
@@ -441,17 +442,7 @@ class FetchState {
         return state.getCsp();
       },
       get logger() {
-        return {
-          info(msg) {
-            logger.info(null, msg);
-          },
-          warn(msg) {
-            logger.warn(null, msg);
-          },
-          error(msg) {
-            logger.error(null, msg);
-          }
-        };
+        return astroToRuntimeLogger(logger);
       }
     };
     this.defineProviderGetters(partial);
@@ -906,17 +897,7 @@ class FetchState {
         return state.getCsp();
       },
       get logger() {
-        return {
-          info(msg) {
-            state.logger.info(null, msg);
-          },
-          warn(msg) {
-            state.logger.warn(null, msg);
-          },
-          error(msg) {
-            state.logger.error(null, msg);
-          }
-        };
+        return astroToRuntimeLogger(state.logger);
       }
     };
     this.defineProviderGetters(ctx);

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

@@ -1,3 +1,4 @@
+import type { AstroRuntimeLogger } from '../../types/public/context.js';
 export interface AstroLoggerDestination {
     /**
      * It receives a message and writes it into a destination
@@ -109,4 +110,5 @@ export declare class AstroIntegrationLogger {
      */
     close(): void;
 }
+export declare function astroToRuntimeLogger(logger: AstroLogger): AstroRuntimeLogger;
 export {};

package/dist/core/logger/core.js

@@ -186,9 +186,23 @@ class AstroIntegrationLogger {
     }
   }
 }
+function astroToRuntimeLogger(logger) {
+  return {
+    info(msg) {
+      logger.info(null, msg);
+    },
+    warn(msg) {
+      logger.warn(null, msg);
+    },
+    error(msg) {
+      logger.error(null, msg);
+    }
+  };
+}
 export {
   AstroIntegrationLogger,
   AstroLogger,
+  astroToRuntimeLogger,
   dateTimeFormat,
   debug,
   getEventPrefix,

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

@@ -24,7 +24,18 @@ export declare function emitDestination(config: NormalizedLoggerConfig, resolveE
  * destinations continue numbering where their parent left off.
  */
 nameOffset?: number): Promise<EmittedDestination>;
-export declare function vitePluginLogger({ settings, }: {
+/**
+ * Emits `virtual:astro:logger`: the configured destination as the default export
+ * (`null` when the user configured none) plus the resolved log level.
+ *
+ * The module is always registered, even without a `logger` config, so that code
+ * generated ahead of the user's config — `astro:content`, which is built from a
+ * static template — can import it unconditionally. It deliberately imports
+ * nothing but the user's destination entrypoint: unlike `virtual:astro:manifest`
+ * it is a leaf, so reaching a logger through it cannot pull renderers and pages
+ * into an importer's module graph.
+ */
+export declare function vitePluginLogger({ settings }: {
     settings: AstroSettings;
-}): VitePlugin | undefined;
+}): VitePlugin;
 export {};