astro 6.0.2 → 6.0.3

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

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

package/dist/content/content-layer.js

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

package/dist/core/build/generate.js

@@ -139,6 +139,16 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
       );
     }
   }
+  for (const { route: generatedRoute } of filteredPaths) {
+    if (generatedRoute.distURL && generatedRoute.distURL.length > 0) {
+      for (const pageData of Object.values(options.allPages)) {
+        if (pageData.route.route === generatedRoute.route && pageData.route.component === generatedRoute.component) {
+          pageData.route.distURL = generatedRoute.distURL;
+          break;
+        }
+      }
+    }
+  }
   const staticImageList = getStaticImageList();
   if (prerenderer.collectStaticImages) {
     const adapterImages = await prerenderer.collectStaticImages();

package/dist/core/constants.d.ts

@@ -66,6 +66,10 @@ export declare const originPathnameSymbol: unique symbol;
  * Use this symbol to set and retrieve the pipeline.
  */
 export declare const pipelineSymbol: unique symbol;
+/**
+ * Use this symbol to opt into handling prerender routes in Astro core dev middleware.
+ */
+export declare const devPrerenderMiddlewareSymbol: unique symbol;
 /**
  * The symbol used as a field on the request object to store a cleanup callback associated with aborting the request when the underlying socket closes.
  */

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "6.0.2";
+const ASTRO_VERSION = "6.0.3";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
@@ -12,6 +12,7 @@ const clientAddressSymbol = /* @__PURE__ */ Symbol.for("astro.clientAddress");
 const clientLocalsSymbol = /* @__PURE__ */ Symbol.for("astro.locals");
 const originPathnameSymbol = /* @__PURE__ */ Symbol.for("astro.originPathname");
 const pipelineSymbol = /* @__PURE__ */ Symbol.for("astro.pipeline");
+const devPrerenderMiddlewareSymbol = /* @__PURE__ */ Symbol.for("astro.devPrerenderMiddleware");
 const nodeRequestAbortControllerCleanupSymbol = /* @__PURE__ */ Symbol.for(
   "astro.nodeRequestAbortControllerCleanup"
 );
@@ -57,6 +58,7 @@ export {
   SUPPORTED_MARKDOWN_FILE_EXTENSIONS,
   clientAddressSymbol,
   clientLocalsSymbol,
+  devPrerenderMiddlewareSymbol,
   nodeRequestAbortControllerCleanupSymbol,
   originPathnameSymbol,
   pipelineSymbol,

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 = "6.0.2";
+  const currentVersion = "6.0.3";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/messages/runtime.js

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

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

@@ -59,10 +59,10 @@ async function getRequestData(request, bodySizeLimit = DEFAULT_BODY_SIZE_LIMIT)
         const body = await readBodyWithLimit(request, bodySizeLimit);
         const raw = new TextDecoder().decode(body);
         const data = JSON.parse(raw);
-        if ("slots" in data && typeof data.slots === "object") {
+        if (Object.hasOwn(data, "slots") && typeof data.slots === "object") {
           return badRequest("Plaintext slots are not allowed. Slots must be encrypted.");
         }
-        if ("componentExport" in data && typeof data.componentExport === "string") {
+        if (Object.hasOwn(data, "componentExport") && typeof data.componentExport === "string") {
           return badRequest(
             "Plaintext componentExport is not allowed. componentExport must be encrypted."
           );

package/dist/vite-plugin-astro-server/plugin.js

@@ -3,7 +3,7 @@ import { IncomingMessage } from "node:http";
 import { isRunnableDevEnvironment } from "vite";
 import { toFallbackType } from "../core/app/common.js";
 import { toRoutingStrategy } from "../core/app/entrypoints/index.js";
-import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES, devPrerenderMiddlewareSymbol } from "../core/constants.js";
 import {
   getAlgorithm,
   getDirectives,
@@ -19,6 +19,7 @@ import { getViteErrorPayload } from "../core/errors/dev/index.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { NOOP_MIDDLEWARE_FN } from "../core/middleware/noop-middleware.js";
 import { createViteLoader } from "../core/module-loader/index.js";
+import { matchAllRoutes } from "../core/routing/match.js";
 import { resolveMiddlewareMode } from "../integrations/adapter-utils.js";
 import { SERIALIZED_MANIFEST_ID } from "../manifest/serialized.js";
 import { ASTRO_DEV_SERVER_APP_ID } from "../vite-plugin-app/index.js";
@@ -40,15 +41,23 @@ function createVitePluginAstroServer({
       return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr;
     },
     async configureServer(viteServer) {
-      if (!isRunnableDevEnvironment(viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr])) {
+      const ssrEnvironment = viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      const prerenderEnvironment = viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.prerender];
+      const runnableSsrEnvironment = isRunnableDevEnvironment(ssrEnvironment) ? ssrEnvironment : void 0;
+      const runnablePrerenderEnvironment = isRunnableDevEnvironment(prerenderEnvironment) ? prerenderEnvironment : void 0;
+      if (!runnableSsrEnvironment && !runnablePrerenderEnvironment) {
         return;
       }
-      const environment = viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
-      const loader = createViteLoader(viteServer, environment);
-      const { default: createAstroServerApp } = await environment.runner.import(ASTRO_DEV_SERVER_APP_ID);
-      const controller = createController({ loader });
-      const { handler } = await createAstroServerApp(controller, settings, loader, logger);
-      const { manifest } = await environment.runner.import(SERIALIZED_MANIFEST_ID);
+      async function createHandler(environment) {
+        const loader = createViteLoader(viteServer, environment);
+        const { default: createAstroServerApp } = await environment.runner.import(ASTRO_DEV_SERVER_APP_ID);
+        const controller = createController({ loader });
+        const { handler } = await createAstroServerApp(controller, settings, loader, logger);
+        const { manifest } = await environment.runner.import(SERIALIZED_MANIFEST_ID);
+        return { controller, handler, loader, manifest, environment };
+      }
+      const ssrHandler = runnableSsrEnvironment ? await createHandler(runnableSsrEnvironment) : void 0;
+      const prerenderHandler = runnablePrerenderEnvironment ? await createHandler(runnablePrerenderEnvironment) : void 0;
       const localStorage = new AsyncLocalStorage();
       function handleUnhandledRejection(rejection) {
         const error = AstroError.is(rejection) ? rejection : new AstroError({
@@ -56,20 +65,36 @@ function createVitePluginAstroServer({
           message: AstroErrorData.UnhandledRejection.message(rejection?.stack || rejection)
         });
         const store = localStorage.getStore();
-        if (store instanceof IncomingMessage) {
-          setRouteError(controller.state, store.url, error);
+        const handlers = [];
+        if (ssrHandler) handlers.push(ssrHandler);
+        if (prerenderHandler) handlers.push(prerenderHandler);
+        for (const currentHandler of handlers) {
+          if (store instanceof IncomingMessage) {
+            setRouteError(currentHandler.controller.state, store.url, error);
+          }
+          const { errorWithMetadata } = recordServerError(
+            currentHandler.loader,
+            currentHandler.manifest,
+            logger,
+            error
+          );
+          setTimeout(
+            async () => currentHandler.loader.webSocketSend(await getViteErrorPayload(errorWithMetadata)),
+            200
+          );
         }
-        const { errorWithMetadata } = recordServerError(loader, manifest, logger, error);
-        setTimeout(
-          async () => loader.webSocketSend(await getViteErrorPayload(errorWithMetadata)),
-          200
-        );
       }
       process.on("unhandledRejection", handleUnhandledRejection);
       viteServer.httpServer?.on("close", () => {
         process.off("unhandledRejection", handleUnhandledRejection);
       });
       return () => {
+        const shouldHandlePrerenderInCore = Boolean(
+          viteServer[devPrerenderMiddlewareSymbol]
+        );
+        if (!ssrHandler && !(prerenderHandler && shouldHandlePrerenderInCore)) {
+          return;
+        }
         viteServer.middlewares.stack.unshift({
           route: "",
           handle: baseMiddleware(settings, logger)
@@ -86,16 +111,49 @@ function createVitePluginAstroServer({
           route: "",
           handle: secFetchMiddleware(logger, settings.config.security?.allowedDomains)
         });
-        viteServer.middlewares.use(async function astroDevHandler(request, response) {
-          if (request.url === void 0 || !request.method) {
-            response.writeHead(500, "Incomplete request");
-            response.end();
-            return;
-          }
-          localStorage.run(request, () => {
-            handler(request, response);
+        if (prerenderHandler && shouldHandlePrerenderInCore) {
+          viteServer.middlewares.use(
+            async function astroDevPrerenderHandler(request, response, next) {
+              if (request.url === void 0 || !request.method) {
+                response.writeHead(500, "Incomplete request");
+                response.end();
+                return;
+              }
+              if (request.url.startsWith("/@") || request.url.startsWith("/__")) {
+                return next();
+              }
+              if (request.url.includes("/node_modules/")) {
+                return next();
+              }
+              try {
+                const pathname = decodeURI(new URL(request.url, "http://localhost").pathname);
+                const { routes } = await prerenderHandler.environment.runner.import("virtual:astro:routes");
+                const routesList = { routes: routes.map((r) => r.routeData) };
+                const matches = matchAllRoutes(pathname, routesList);
+                if (!matches.some((route) => route.prerender)) {
+                  return next();
+                }
+                localStorage.run(request, () => {
+                  prerenderHandler.handler(request, response);
+                });
+              } catch (err) {
+                next(err);
+              }
+            }
+          );
+        }
+        if (ssrHandler) {
+          viteServer.middlewares.use(async function astroDevHandler(request, response) {
+            if (request.url === void 0 || !request.method) {
+              response.writeHead(500, "Incomplete request");
+              response.end();
+              return;
+            }
+            localStorage.run(request, () => {
+              ssrHandler.handler(request, response);
+            });
           });
-        });
+        }
       };
     }
   };

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

@@ -42,16 +42,19 @@ function* collectCSSWithOrder(id, mod, seen = /* @__PURE__ */ new Set()) {
   }
 }
 function astroDevCssPlugin({ routesList, command }) {
-  let ssrEnvironment = void 0;
+  let server;
   const cssContentCache = /* @__PURE__ */ new Map();
+  function getCurrentEnvironment(pluginEnv) {
+    return pluginEnv ?? server?.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+  }
   return [
     {
       name: MODULE_DEV_CSS,
-      async configureServer(server) {
-        ssrEnvironment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      async configureServer(viteServer) {
+        server = viteServer;
       },
       applyToEnvironment(env) {
-        return env.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.client;
+        return env.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.client || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
       },
       resolveId: {
         filter: {
@@ -81,14 +84,15 @@ function astroDevCssPlugin({ routesList, command }) {
             );
             const cssWithOrder = /* @__PURE__ */ new Map();
             const componentPageId = getVirtualModulePageNameForComponent(componentPath);
-            await ssrEnvironment?.fetchModule(componentPageId);
-            const resolved = await ssrEnvironment?.pluginContainer.resolveId(componentPageId);
+            const env = getCurrentEnvironment(this.environment);
+            await env?.fetchModule(componentPageId);
+            const resolved = await env?.pluginContainer.resolveId(componentPageId);
             if (!resolved?.id) {
               return {
                 code: "export const css = new Set()"
               };
             }
-            const mod = ssrEnvironment?.moduleGraph.getModuleById(resolved.id);
+            const mod = env?.moduleGraph.getModuleById(resolved.id);
             if (!mod) {
               return {
                 code: "export const css = new Set()"
@@ -123,7 +127,8 @@ function astroDevCssPlugin({ routesList, command }) {
           if (command === "build") {
             return;
           }
-          const mod = ssrEnvironment?.moduleGraph.getModuleById(id);
+          const env = getCurrentEnvironment(this.environment);
+          const mod = env?.moduleGraph.getModuleById(id);
           if (mod) {
             cssContentCache.set(id, code);
           }
@@ -133,7 +138,7 @@ function astroDevCssPlugin({ routesList, command }) {
     {
       name: MODULE_DEV_CSS_ALL,
       applyToEnvironment(env) {
-        return env.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.client || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.astro;
+        return env.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.client || env.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
       },
       resolveId: {
         filter: {

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

@@ -77,11 +77,22 @@ async function astroPluginRoutes({
           routeData: serializeRouteData(r, settings.config.trailingSlash)
         };
       });
-      let environment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
-      const virtualMod = environment.moduleGraph.getModuleById(ASTRO_ROUTES_MODULE_ID_RESOLVED);
-      if (!virtualMod) return;
-      environment.moduleGraph.invalidateModule(virtualMod);
-      environment.hot.send("astro:routes-updated", {});
+      const environmentsToInvalidate = [];
+      for (const name of [
+        ASTRO_VITE_ENVIRONMENT_NAMES.ssr,
+        ASTRO_VITE_ENVIRONMENT_NAMES.prerender
+      ]) {
+        const environment = server.environments[name];
+        if (environment) {
+          environmentsToInvalidate.push(environment);
+        }
+      }
+      for (const environment of environmentsToInvalidate) {
+        const virtualMod = environment.moduleGraph.getModuleById(ASTRO_ROUTES_MODULE_ID_RESOLVED);
+        if (!virtualMod) continue;
+        environment.moduleGraph.invalidateModule(virtualMod);
+        environment.hot.send("astro:routes-updated", {});
+      }
     }
   }
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "6.0.2",
+  "version": "6.0.3",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -153,9 +153,9 @@
     "xxhash-wasm": "^1.1.0",
     "yargs-parser": "^22.0.0",
     "zod": "^4.3.6",
-    "@astrojs/internal-helpers": "0.8.0",
+    "@astrojs/markdown-remark": "7.0.0",
     "@astrojs/telemetry": "3.3.0",
-    "@astrojs/markdown-remark": "7.0.0"
+    "@astrojs/internal-helpers": "0.8.0"
   },
   "optionalDependencies": {
     "sharp": "^0.34.0"