astro 7.2.9 → 7.3.0

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/server-islands/vite-plugin-server-islands.js

@@ -5,8 +5,8 @@ const RESOLVED_SERVER_ISLAND_MANIFEST = "\0" + SERVER_ISLAND_MANIFEST;
 const serverIslandPlaceholderMap = "'$$server-islands-map$$'";
 const serverIslandPlaceholderNameMap = "'$$server-islands-name-map$$'";
 const SERVER_ISLAND_MAP_MARKER = "$$server-islands-map$$";
-const serverIslandMapReplaceExp = /['"]\$\$server-islands-map\$\$['"]/g;
-const serverIslandNameMapReplaceExp = /['"]\$\$server-islands-name-map\$\$['"]/g;
+const serverIslandMapReplaceExp = /['"`]\$\$server-islands-map\$\$['"`]/g;
+const serverIslandNameMapReplaceExp = /['"`]\$\$server-islands-name-map\$\$['"`]/g;
 function vitePluginServerIslands({
   settings,
   serverIslandsState

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/core/util.d.ts

@@ -23,15 +23,6 @@ export declare function wrapId(id: string): string;
 export declare function resolvePages(config: AstroConfig): URL;
 export declare function isPage(file: URL, settings: AstroSettings): boolean;
 export declare function isEndpoint(file: URL, settings: AstroSettings): boolean;
-export declare function resolveJsToTs(filePath: string): string;
-/**
- * Resolve a path that doesn't name a file on disk (e.g. produced by an
- * extensionless import like `import { Counter } from './Counter'`) to the file
- * Vite would load, by probing Vite's default extension order and directory
- * `index` files. Returns the path unchanged when it already exists as a file
- * or when no candidate is found.
- */
-export declare function resolveExtensionlessPath(filePath: string): string;
 /**
  * Set a default NODE_ENV so Vite doesn't set an incorrect default when loading the Astro config
  */

package/dist/core/util.js

@@ -1,4 +1,3 @@
-import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import { hasSpecialQueries } from "../vite-plugin-utils/index.js";
 import { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from "./constants.js";
@@ -85,37 +84,6 @@ function isEndpoint(file, settings) {
   if (!isPublicRoute(file, settings.config)) return false;
   return !endsWithPageExt(file, settings) && !file.toString().includes("?astro");
 }
-function resolveJsToTs(filePath) {
-  if (filePath.endsWith(".jsx") && !fs.existsSync(filePath)) {
-    const tryPath = filePath.slice(0, -4) + ".tsx";
-    if (fs.existsSync(tryPath)) {
-      return tryPath;
-    }
-  }
-  return filePath;
-}
-const VITE_DEFAULT_RESOLVE_EXTENSIONS = [".mjs", ".js", ".mts", ".ts", ".jsx", ".tsx", ".json"];
-function resolveExtensionlessPath(filePath) {
-  const stat = fs.statSync(filePath, { throwIfNoEntry: false });
-  if (stat?.isFile()) {
-    return filePath;
-  }
-  for (const ext of VITE_DEFAULT_RESOLVE_EXTENSIONS) {
-    const tryPath = filePath + ext;
-    if (fs.existsSync(tryPath)) {
-      return tryPath;
-    }
-  }
-  if (stat?.isDirectory()) {
-    for (const ext of VITE_DEFAULT_RESOLVE_EXTENSIONS) {
-      const tryPath = `${filePath}/index${ext}`;
-      if (fs.existsSync(tryPath)) {
-        return tryPath;
-      }
-    }
-  }
-  return filePath;
-}
 function ensureProcessNodeEnv(defaultNodeEnv) {
   if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = defaultNodeEnv;
@@ -128,8 +96,6 @@ export {
   isMarkdownFile,
   isPage,
   parseNpmName,
-  resolveExtensionlessPath,
-  resolveJsToTs,
   resolvePages,
   unwrapId,
   viteID,

package/dist/core/viteUtils.d.ts

@@ -1,21 +1,9 @@
 import type { ModuleLoader } from './module-loader/index.js';
+export { resolvePath } from '@astrojs/internal-helpers/mdx';
 /**
  * Re-implementation of Vite's normalizePath that can be used without Vite
  */
 export declare function normalizePath(id: string): string;
-/**
- * Resolve island component specifiers to stable paths for hydration metadata.
- *
- * Examples:
- * - `./components/Button.jsx` from `/app/src/pages/index.astro`
- *   -> `/app/src/pages/components/Button.tsx` (when `.tsx` exists)
- * - `../components/Counter` from `/app/src/pages/index.astro`
- *   -> `/app/src/components/Counter.tsx` (extensionless imports probe Vite's
- *   default extension order, then directory `index` files)
- * - `#components/react/Counter.tsx`
- *   -> `/app/src/components/react/Counter.tsx` via package `imports`
- */
-export declare function resolvePath(specifier: string, importer: string): string;
 export declare function rootRelativePath(root: URL, idOrUrl: URL | string, shouldPrependForwardSlash?: boolean): string;
 /**
  * Simulate Vite's resolve and import analysis so we can import the id as an URL

package/dist/core/viteUtils.js

@@ -1,42 +1,12 @@
-import { createRequire } from "node:module";
 import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
 import { prependForwardSlash, slash } from "../core/path.js";
-import {
-  resolveExtensionlessPath,
-  resolveJsToTs,
-  unwrapId,
-  VALID_ID_PREFIX,
-  viteID
-} from "./util.js";
+import { unwrapId, VALID_ID_PREFIX, viteID } from "./util.js";
+import { resolvePath } from "@astrojs/internal-helpers/mdx";
 const isWindows = typeof process !== "undefined" && process.platform === "win32";
 function normalizePath(id) {
   return path.posix.normalize(isWindows ? slash(id) : id);
 }
-function resolvePath(specifier, importer) {
-  if (specifier.startsWith(".")) {
-    const absoluteSpecifier = path.resolve(path.dirname(importer), specifier);
-    return resolveExtensionlessPath(resolveJsToTs(normalizePath(absoluteSpecifier)));
-  } else if (specifier.startsWith("#")) {
-    try {
-      const resolved = createRequire(pathToFileURL(importer)).resolve(specifier);
-      return resolveJsToTs(normalizePath(resolved));
-    } catch {
-      try {
-        const importerURL = pathToFileURL(importer).toString();
-        const resolved = import.meta.resolve(specifier, importerURL);
-        const resolvedUrl = new URL(resolved);
-        if (resolvedUrl.protocol === "file:") {
-          return resolveJsToTs(normalizePath(fileURLToPath(resolvedUrl)));
-        }
-      } catch {
-      }
-    }
-    return specifier;
-  } else {
-    return specifier;
-  }
-}
 function rootRelativePath(root, idOrUrl, shouldPrependForwardSlash = true) {
   let id;
   if (typeof idOrUrl !== "string") {

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-app/createAstroServerApp.js

@@ -47,7 +47,7 @@ async function createAstroServerApp(controller, settings, loader, logger) {
         const { routes: newRoutes } = await import("virtual:astro:routes");
         updateRouteTable(
           manifest,
-          newRoutes.map((r) => r.routeData)
+          newRoutes.map((route) => route.routeData)
         );
         actualLogger.debug("router", "Routes updated via HMR");
       } catch (e) {

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.9",
+  "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,16 +152,16 @@
     "vitefu": "^1.1.2",
     "xxhash-wasm": "^1.1.0",
     "yargs-parser": "^22.0.0",
-    "zod": "^4.3.6",
-    "@astrojs/markdown-satteri": "0.3.8",
-    "@astrojs/internal-helpers": "0.10.4",
+    "zod": "^4.5.4",
+    "@astrojs/internal-helpers": "0.11.0",
+    "@astrojs/markdown-satteri": "0.4.0",
     "@astrojs/telemetry": "3.3.3"
   },
   "optionalDependencies": {
     "sharp": "^0.35.4"
   },
   "peerDependencies": {
-    "@astrojs/markdown-remark": "7.2.4"
+    "@astrojs/markdown-remark": "^7.3.0"
   },
   "peerDependenciesMeta": {
     "@astrojs/markdown-remark": {
@@ -193,8 +193,8 @@
     "typescript": "^6.0.3",
     "undici": "^7.22.0",
     "vitest": "^4.1.0",
-    "@astrojs/markdown-remark": "7.2.4",
     "@astrojs/check": "0.9.10",
+    "@astrojs/markdown-remark": "7.3.0",
     "astro-scripts": "0.0.14"
   },
   "engines": {

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