astro 7.2.9 → 7.3.0

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/runtime/cache.js

@@ -75,6 +75,9 @@ class AstroCache {
     for (const [key, value] of headers) {
       response.headers.set(key, value);
     }
+    if (!response.headers.has("Cache-Control") && !response.headers.has("Expires") && (response.headers.has("Last-Modified") || response.headers.has("ETag"))) {
+      response.headers.set("Cache-Control", "no-cache");
+    }
   }
   /** @internal */
   get [IS_ACTIVE]() {

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.9";
+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

@@ -4,7 +4,7 @@ import colors from "piccolore";
 import { gt, major, minor, patch } from "semver";
 import { getDataStoreChunkSize, getDataStoreDir, getDataStoreFile } from "../../content/paths.js";
 import { globalContentLayer } from "../../content/instance.js";
-import { attachContentServerListeners } from "../../content/index.js";
+import { attachContentServerListeners, attachDataStoreInvalidation } from "../../content/index.js";
 import { MutableDataStore } from "../../content/mutable-data-store.js";
 import { globalContentConfigObserver } from "../../content/utils.js";
 import { telemetry } from "../../events/index.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.9";
+  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);
@@ -69,6 +69,8 @@ async function dev(inlineConfig) {
   }
   if (!store) {
     logger.error("content", "Failed to create data store");
+  } else {
+    attachDataStoreInvalidation(store, restart.container.viteServer, restart.container.settings);
   }
   await attachContentServerListeners(restart.container);
   const config = globalContentConfigObserver.get();

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 {};

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

@@ -35,13 +35,8 @@ async function emitDestination(config, resolveEntrypoint, nameOffset = 0) {
   }
   return { expression: `${name}(${JSON.stringify(config.config) ?? "undefined"})`, imports };
 }
-function vitePluginLogger({
-  settings
-}) {
+function vitePluginLogger({ settings }) {
   const loggerConfig = settings.config.logger;
-  if (!loggerConfig) {
-    return;
-  }
   return {
     name: VIRTUAL_LOGGER_ID,
     enforce: "pre",
@@ -58,6 +53,12 @@ function vitePluginLogger({
         id: new RegExp(`^${RESOLVED_VIRTUAL_LOGGER_ID}$`)
       },
       async handler() {
+        const level = `export const level = ${JSON.stringify(settings.logLevel)};
+`;
+        if (!loggerConfig) {
+          return { code: `${level}export default null;
+` };
+        }
         const importerPath = fileURLToPath(new URL("package.json", settings.config.root));
         const { expression, imports } = await emitDestination(
           normalizeLoggerConfig(loggerConfig, settings.config.root),
@@ -65,7 +66,7 @@ function vitePluginLogger({
         );
         return {
           code: `${imports.join("\n")}
-export default ${expression};
+${level}export default ${expression};
 `
         };
       }

package/dist/core/messages/runtime.js

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

package/dist/core/middleware/index.js

@@ -8,8 +8,21 @@ import { DisabledAstroCache } from "../cache/runtime/noop.js";
 import { ASTRO_GENERATOR } from "../constants.js";
 import { AstroCookies } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
+import { getLogger } from "../logger/manifest-logger.js";
+import { tryGetAmbientManifest } from "../manifest/ambient.js";
 import { getOriginPathname } from "../routing/rewrite.js";
 import { sequence } from "./sequence.js";
+function getMiddlewareLogger() {
+  const manifest = tryGetAmbientManifest();
+  if (manifest) {
+    return getLogger(manifest);
+  }
+  return {
+    warn(_label, message) {
+      console.warn(message);
+    }
+  };
+}
 function createContext({
   request,
   params = {},
@@ -27,7 +40,7 @@ function createContext({
     return Promise.resolve(new Response(null));
   };
   const context = {
-    cookies: new AstroCookies(request),
+    cookies: new AstroCookies(request, getMiddlewareLogger()),
     request,
     params,
     site: void 0,

package/dist/core/render-scope/collect.d.ts

@@ -0,0 +1,24 @@
+import type { SerializedStaticImage } from '../../assets/types.js';
+import type { AstroLogger } from '../logger/core.js';
+export interface CollectedPrerenderMetadata {
+    contentEntryKeys: string[];
+    staticImages: SerializedStaticImage[];
+}
+/**
+ * Runs `fn` inside a fresh per-render collectors store and returns its value
+ * together with a snapshot of everything recorded while it ran.
+ *
+ * When no render scope is installed, collection degrades to *not collecting*:
+ * warn once per process, run `fn` bare, and return `metadata: undefined`
+ * ("not tracked") — never wrong attribution.
+ *
+ * Invariant: `fn` must not resolve until all recordable work is done — in
+ * practice, until the response body is fully buffered inside `fn`. The
+ * snapshot is taken by copy when `fn` resolves, so a late-arriving record (a
+ * floating promise carrying the async context past buffering) mutates only the
+ * abandoned store, never the returned metadata.
+ */
+export declare function collectPrerenderMetadata<T>(fn: () => Promise<T>, logger: AstroLogger): Promise<{
+    value: T;
+    metadata: CollectedPrerenderMetadata | undefined;
+}>;

package/dist/core/render-scope/collect.js

@@ -0,0 +1,27 @@
+import { getInstalledRenderScope } from "./scope.js";
+let warnedNoScope = false;
+async function collectPrerenderMetadata(fn, logger) {
+  const scope = getInstalledRenderScope();
+  if (!scope) {
+    if (!warnedNoScope) {
+      warnedNoScope = true;
+      logger.warn(
+        "build",
+        "A prerenderer requested metadata collection but no render scope is installed; install one with `installRenderScope` from `astro/app` \u2014 incremental metadata will not be collected for prerendered paths."
+      );
+    }
+    return { value: await fn(), metadata: void 0 };
+  }
+  const store = { contentEntries: /* @__PURE__ */ new Set(), staticImages: [] };
+  const value = await scope.run(store, fn);
+  return {
+    value,
+    metadata: {
+      contentEntryKeys: [...store.contentEntries],
+      staticImages: [...store.staticImages]
+    }
+  };
+}
+export {
+  collectPrerenderMetadata
+};

package/dist/core/render-scope/node-scope.d.ts

@@ -0,0 +1,10 @@
+import type { RenderCollectorScope } from './scope.js';
+/**
+ * Installs (first-wins) an AsyncLocalStorage-backed render scope and returns
+ * the installed scope.
+ *
+ * This module is the ONE static `node:async_hooks` import in core and must be
+ * imported ONLY by `core/build/default-prerenderer.ts` — orchestrator-only
+ * code that is never bundled into prerender, server, or adapter output.
+ */
+export declare function ensureAsyncRenderScope(): RenderCollectorScope;

package/dist/core/render-scope/node-scope.js

@@ -0,0 +1,8 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { installRenderScope } from "./scope.js";
+function ensureAsyncRenderScope() {
+  return installRenderScope(new AsyncLocalStorage());
+}
+export {
+  ensureAsyncRenderScope
+};

package/dist/core/render-scope/record.d.ts

@@ -0,0 +1,14 @@
+import type { SerializedStaticImage } from '../../assets/types.js';
+/**
+ * Records that a content entry was rendered, keyed by its root-relative
+ * `filePath`. No-op when no scope is installed (dev, production SSR,
+ * non-incremental builds) or no render is in scope (`getStaticPaths`, module
+ * top-level).
+ */
+export declare function recordContentEntryRender(filePath: string | undefined): void;
+/**
+ * Records a resolved image transform, dedup hits included, preserving
+ * duplicates (array push, not a set — replay depends on every record
+ * arriving).
+ */
+export declare function recordStaticImage(image: SerializedStaticImage): void;

package/dist/core/render-scope/record.js

@@ -0,0 +1,12 @@
+import { getInstalledRenderScope } from "./scope.js";
+function recordContentEntryRender(filePath) {
+  if (!filePath) return;
+  getInstalledRenderScope()?.getStore()?.contentEntries?.add(filePath);
+}
+function recordStaticImage(image) {
+  getInstalledRenderScope()?.getStore()?.staticImages?.push(image);
+}
+export {
+  recordContentEntryRender,
+  recordStaticImage
+};

package/dist/core/render-scope/scope.d.ts

@@ -0,0 +1,38 @@
+import type { SerializedStaticImage } from '../../assets/types.js';
+/**
+ * The per-render store. One instance is created per collecting render and is
+ * reachable only through the installed {@link RenderCollectorScope} while that
+ * render's async execution is in scope. Fields are optional so record helpers
+ * tolerate stores created by a different astro module instance (or version)
+ * that only knows a subset of collectors.
+ */
+export interface RenderCollectors {
+    /** Root-relative `filePath`s of the content entries rendered. */
+    contentEntries?: Set<string>;
+    /**
+     * Every image transform resolved, dedup hits included; array push,
+     * duplicates preserved.
+     */
+    staticImages?: SerializedStaticImage[];
+}
+/**
+ * Structurally satisfied by `AsyncLocalStorage<RenderCollectors>` — deliberate:
+ * installing an ALS instance directly IS the only shipped implementation.
+ */
+export interface RenderCollectorScope {
+    run<T>(store: RenderCollectors, fn: () => T): T;
+    getStore(): RenderCollectors | undefined;
+}
+/**
+ * Installs a render scope on the process-wide channel and returns the installed
+ * scope. First-wins: when a scope is already installed (possibly by another
+ * module instance), the existing scope is returned and the argument discarded,
+ * so callers that both awaited an import converge on one scope.
+ */
+export declare function installRenderScope(scope: RenderCollectorScope): RenderCollectorScope;
+/** The installed render scope, or `undefined` when none was installed. */
+export declare function getInstalledRenderScope(): RenderCollectorScope | undefined;
+/** Test-only: remove the installed scope so unit tests can reset the channel. */
+export declare function uninstallRenderScope(): void;
+/** The current render's collectors store, or `undefined` when not collecting. */
+export declare function getRenderCollectors(): RenderCollectors | undefined;