astro 7.2.10 → 7.3.0

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.10"}`
+        `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;

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

@@ -0,0 +1,28 @@
+const SCOPE_KEY = /* @__PURE__ */ Symbol.for("astro:render-scope");
+function installRenderScope(scope) {
+  const host = globalThis;
+  const existing = host[SCOPE_KEY];
+  if (existing) return existing;
+  Object.defineProperty(host, SCOPE_KEY, {
+    value: scope,
+    configurable: true,
+    writable: false,
+    enumerable: false
+  });
+  return scope;
+}
+function getInstalledRenderScope() {
+  return globalThis[SCOPE_KEY];
+}
+function uninstallRenderScope() {
+  delete globalThis[SCOPE_KEY];
+}
+function getRenderCollectors() {
+  return getInstalledRenderScope()?.getStore();
+}
+export {
+  getInstalledRenderScope,
+  getRenderCollectors,
+  installRenderScope,
+  uninstallRenderScope
+};

package/dist/core/rewrites/handler.js

@@ -32,7 +32,7 @@ function applyRewriteToState(state, payload, { routeData, componentInstance, new
   }
   state.url = createNormalizedUrl(state.request.url);
   if (mergeCookies) {
-    const newCookies = new AstroCookies(state.request);
+    const newCookies = new AstroCookies(state.request, state.logger);
     if (state.cookies) {
       newCookies.merge(state.cookies);
     }

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

@@ -683,7 +683,11 @@ function joinSegments(segments) {
 }
 function replaceOrKeep(original, from, to) {
   if (original.startsWith(`/${to}/`) || original === `/${to}`) return original;
-  return original.replace(`/${from}/`, `/${to}/`).replace(`/${from}`, `/${to}`);
+  const segments = original.split("/");
+  const index = segments.indexOf(from);
+  if (index === -1) return original;
+  segments[index] = to;
+  return segments.join("/");
 }
 export {
   createI18nFallbackRoutes,

package/dist/core/server-islands/endpoint.js

@@ -1,4 +1,5 @@
 import {
+  markHTMLString,
   renderComponent,
   renderTemplate
 } from "../../runtime/server/index.js";
@@ -155,7 +156,9 @@ function createEndpoint(manifest) {
       Object.assign(Component, ServerIsland);
       Component.propagation = "self";
     }
-    return renderTemplate`${renderComponent(result, "Component", Component, props, slots)}`;
+    result._metadata.routeHasPropagation = true;
+    const renderPropagatedHead = () => markHTMLString(result._metadata.extraHead.join(""));
+    return renderTemplate`${renderPropagatedHead}${renderComponent(result, "Component", Component, props, slots)}`;
   };
   page.isAstroComponentFactory = true;
   const instance = {

package/dist/core/sync/index.js

@@ -101,7 +101,7 @@ async function syncInternal({
         const chunkSize = getDataStoreChunkSize(settings);
         if (chunkSize !== void 0) {
           const dataStoreDir = getDataStoreDir(settings, isDev);
-          store = await MutableDataStore.fromDir(dataStoreDir, chunkSize);
+          store = await MutableDataStore.fromDir(dataStoreDir, chunkSize, logger);
         } else {
           const dataStoreFile = getDataStoreFile(settings, isDev);
           store = await MutableDataStore.fromFile(dataStoreFile);

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

@@ -197,21 +197,23 @@ export interface PathWithRoute {
     cacheKey?: string;
 }
 /**
- * Incremental-build data an out-of-process prerenderer collects while rendering
- * a page, reported back to the build process so skipped pages can be tracked and
- * replayed without a re-render.
+ * Incremental-build data a prerenderer collects while rendering a page,
+ * reported back to the build orchestrator so skipped pages can be tracked and
+ * replayed without a re-render. This is the only attribution channel: every
+ * prerenderer — in-process and out-of-process — collects in its own rendering
+ * runtime and reports the result by value here.
  */
 export interface PrerenderRenderMetadata {
-    /** Root-relative `filePath`s of the content entries the page rendered. */
-    contentEntryKeys?: string[];
-    /** Optimized-image transforms the page resolved. */
-    staticImages?: SerializedStaticImage[];
+    /** Root-relative `filePath`s of the content entries the page rendered, or an empty array. */
+    contentEntryKeys: string[];
+    /** Optimized-image transforms the page resolved, or an empty array. */
+    staticImages: SerializedStaticImage[];
 }
 /**
  * The richer result a prerenderer's `render()` may return instead of a bare
  * `Response`, pairing the rendered response with the incremental-build metadata
- * collected for that page. Used by out-of-process prerenderers, which collect
- * the metadata in their own runtime rather than in the build's collectors.
+ * collected for that page. `metadata` is `undefined` when the page was not
+ * tracked (collection was not requested, or the prerenderer could not collect).
  */
 export interface PrerenderResult {
     response: Response;
@@ -239,14 +241,19 @@ export interface AstroPrerenderer {
      *   use the `pathname` from the `PathWithRoute` entry returned by `getStaticPaths`.
      * @param options - Render options
      * @param options.routeData - The matched route for this path
+     * @param options.collectMetadata - True exactly when the incremental build
+     *   cache is active. The prerenderer should collect the page's per-render
+     *   incremental metadata in its rendering runtime and report it on a
+     *   {@link PrerenderResult}. A prerenderer that cannot collect may ignore the
+     *   flag and return a bare `Response`; its paths are then recorded as
+     *   "not tracked".
      * @returns A `Response`, or a {@link PrerenderResult} pairing the response with
-     *   the incremental-build metadata the page resolved. Out-of-process
-     *   prerenderers return the latter to report metadata they collect in their own
-     *   runtime; in-process prerenderers populate the build's collectors directly
-     *   and return a bare `Response`.
+     *   the incremental-build metadata the page resolved. Metadata is the only
+     *   attribution channel for all prerenderers.
      */
     render: (request: Request, options: {
         routeData: RouteData;
+        collectMetadata?: boolean;
     }) => Promise<Response | PrerenderResult>;
     /**
      * Returns images collected in the adapter's runtime (e.g. workerd) to be merged

package/dist/vite-plugin-routes/index.js

@@ -53,6 +53,26 @@ async function astroPluginRoutes({
     }
   );
   const normalizedSrcDir = normalizePath(fileURLToPath(settings.config.srcDir));
+  function findRouteByFilename(filename) {
+    return initialRoutesList.routes.find(
+      (route) => normalizePath(fileURLToPath(new URL(`./${route.component}`, settings.config.root))) === filename
+    );
+  }
+  let routeByFilename = null;
+  function getRouteByFilename() {
+    if (routeByFilename === null) {
+      routeByFilename = /* @__PURE__ */ new Map();
+      for (const route of initialRoutesList.routes) {
+        const filename = normalizePath(
+          fileURLToPath(new URL(`./${route.component}`, settings.config.root))
+        );
+        if (!routeByFilename.has(filename)) {
+          routeByFilename.set(filename, route);
+        }
+      }
+    }
+    return routeByFilename;
+  }
   async function rebuildRoutes(path = null, server) {
     if (path != null && normalizePath(path).startsWith(normalizedSrcDir)) {
       logger.debug(
@@ -157,10 +177,7 @@ async function astroPluginRoutes({
       const fileIsPage = isPage(fileURL, settings);
       const fileIsEndpoint = isEndpoint(fileURL, settings);
       if (!(fileIsPage || fileIsEndpoint)) return;
-      const route = initialRoutesList.routes.find((r) => {
-        const filePath = new URL(`./${r.component}`, settings.config.root);
-        return normalizePath(fileURLToPath(filePath)) === filename;
-      });
+      const route = this.environment.mode === "build" ? getRouteByFilename().get(filename) : findRouteByFilename(filename);
       if (!route) {
         return;
       }
@@ -200,10 +217,7 @@ async function astroPluginRoutes({
       const fileIsPage = isPage(fileURL, settings);
       const fileIsEndpoint = isEndpoint(fileURL, settings);
       if (!(fileIsPage || fileIsEndpoint)) return;
-      const route = initialRoutesList.routes.find((r) => {
-        const filePath = new URL(`./${r.component}`, settings.config.root);
-        return normalizePath(fileURLToPath(filePath)) === filename;
-      });
+      const route = findRouteByFilename(filename);
       if (!route) {
         return;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "7.2.10",
+  "version": "7.3.0",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -152,7 +152,7 @@
     "vitefu": "^1.1.2",
     "xxhash-wasm": "^1.1.0",
     "yargs-parser": "^22.0.0",
-    "zod": "^4.3.6",
+    "zod": "^4.5.4",
     "@astrojs/internal-helpers": "0.11.0",
     "@astrojs/markdown-satteri": "0.4.0",
     "@astrojs/telemetry": "3.3.3"

package/templates/content/module.mjs

@@ -1,3 +1,5 @@
+import { createConsoleLogger } from 'astro/logger/console';
+import loggerDestination, { level } from 'virtual:astro:logger';
 import {
 	createDeprecatedFunction,
 	createGetCollection,
@@ -6,26 +8,32 @@ import {
 	createGetLiveCollection,
 	createGetLiveEntry,
 	createReference,
+	createRenderEntry,
 } from 'astro/content/runtime';
 
-export {
-	defineCollection,
-	defineLiveCollection,
-	renderEntry as render,
-} from 'astro/content/runtime';
+export { defineCollection, defineLiveCollection } from 'astro/content/runtime';
 // TODO: remove in Astro 8
 export { z } from 'astro/zod';
 
 /* @@LIVE_CONTENT_CONFIG@@ */
 
+const logger = createConsoleLogger({ level });
+if (loggerDestination) {
+	logger.setDestination(loggerDestination);
+}
+
 export const getCollection = createGetCollection({
 	liveCollections,
+	logger,
 });
 
 export const getEntry = createGetEntry({
 	liveCollections,
+	logger,
 });
 
+export const render = createRenderEntry({ logger });
+
 export const getEntries = createGetEntries(getEntry);
 
 export const reference = createReference();

package/dist/core/build/incremental-content-collector.d.ts

@@ -1,10 +0,0 @@
-/** Start collecting the content entries rendered on the current path. */
-export declare function beginContentEntryCollection(): void;
-/** Record that a content entry was rendered, keyed by its root-relative `filePath`. */
-export declare function recordContentEntryRender(filePath: string | undefined): void;
-/**
- * Finish collection and return the rendered entries, or `undefined` when no
- * collection was active (so callers can distinguish "nothing rendered" from
- * "not tracked").
- */
-export declare function endContentEntryCollection(): string[] | undefined;

package/dist/core/build/incremental-content-collector.js

@@ -1,33 +0,0 @@
-const COLLECTOR_KEY = /* @__PURE__ */ Symbol.for("astro:incremental-content-entries");
-function collector() {
-  const host = globalThis;
-  let value = host[COLLECTOR_KEY];
-  if (!value) {
-    value = { current: void 0 };
-    Object.defineProperty(host, COLLECTOR_KEY, {
-      value,
-      configurable: false,
-      writable: false,
-      enumerable: false
-    });
-  }
-  return value;
-}
-function beginContentEntryCollection() {
-  collector().current = /* @__PURE__ */ new Set();
-}
-function recordContentEntryRender(filePath) {
-  if (!filePath) return;
-  collector().current?.add(filePath);
-}
-function endContentEntryCollection() {
-  const c = collector();
-  const entries = c.current;
-  c.current = void 0;
-  return entries ? [...entries] : void 0;
-}
-export {
-  beginContentEntryCollection,
-  endContentEntryCollection,
-  recordContentEntryRender
-};

package/dist/core/build/incremental-image-collector.d.ts

@@ -1,11 +0,0 @@
-import type { SerializedStaticImage } from '../../assets/types.js';
-/** Start collecting the image transforms resolved on the current path. */
-export declare function beginImageCollection(): void;
-/** Record an image transform resolved while rendering the current path. */
-export declare function recordStaticImage(image: SerializedStaticImage): void;
-/**
- * Finish collection and return the collected transforms, or `undefined` when no
- * collection was active (so callers can distinguish "no images" from
- * "not tracked").
- */
-export declare function endImageCollection(): SerializedStaticImage[] | undefined;

package/dist/core/build/incremental-image-collector.js

@@ -1,32 +0,0 @@
-const COLLECTOR_KEY = /* @__PURE__ */ Symbol.for("astro:incremental-static-images");
-function collector() {
-  const host = globalThis;
-  let value = host[COLLECTOR_KEY];
-  if (!value) {
-    value = { current: void 0 };
-    Object.defineProperty(host, COLLECTOR_KEY, {
-      value,
-      configurable: false,
-      writable: false,
-      enumerable: false
-    });
-  }
-  return value;
-}
-function beginImageCollection() {
-  collector().current = [];
-}
-function recordStaticImage(image) {
-  collector().current?.push(image);
-}
-function endImageCollection() {
-  const c = collector();
-  const images = c.current;
-  c.current = void 0;
-  return images;
-}
-export {
-  beginImageCollection,
-  endImageCollection,
-  recordStaticImage
-};