astro 5.1.3 → 5.1.4

package/components/Image.astro

@@ -4,7 +4,6 @@ import type { UnresolvedImageTransform } from '../dist/assets/types';
 import { applyResponsiveAttributes } from '../dist/assets/utils/imageAttributes.js';
 import { AstroError, AstroErrorData } from '../dist/core/errors/index.js';
 import type { HTMLAttributes } from '../types';
-import './image.css';
 
 // The TypeScript diagnostic for JSX props uses the last member of the union to suggest props, so it would be better for
 // LocalImageProps to be last. Unfortunately, when we do this the error messages that remote images get are complete nonsense

package/components/Picture.astro

@@ -10,9 +10,8 @@ import type {
 	UnresolvedImageTransform,
 } from '../dist/types/public/index.js';
 import type { HTMLAttributes } from '../types';
-import './image.css';
 
-type Props = (LocalImageProps | RemoteImageProps) & {
+export type Props = (LocalImageProps | RemoteImageProps) & {
 	formats?: ImageOutputFormat[];
 	fallbackFormat?: ImageOutputFormat;
 	pictureAttributes?: HTMLAttributes<'picture'>;

package/components/ResponsiveImage.astro

@@ -0,0 +1,13 @@
+---
+import type { LocalImageProps, RemoteImageProps } from 'astro:assets';
+import Image from './Image.astro';
+
+type Props = LocalImageProps | RemoteImageProps;
+
+const { class: className, ...props } = Astro.props;
+
+import './image.css';
+---
+
+{/* Applying class outside of the spread prevents it from applying unnecessary astro-* classes */}
+<Image {...props} class={className} />

package/components/ResponsivePicture.astro

@@ -0,0 +1,11 @@
+---
+import { default as Picture, type Props as PictureProps } from './Picture.astro';
+
+type Props = PictureProps;
+
+const { class: className, ...props } = Astro.props;
+---
+
+{/* Applying class outside of the spread prevents it from applying unnecessary astro-* classes */}
+
+<Picture {...props} class={className} />

package/dist/assets/build/generate.js

@@ -85,8 +85,10 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     const finalFileURL = new URL("." + filepath, env.clientRoot);
     const finalFolderURL = new URL("./", finalFileURL);
     await fs.promises.mkdir(finalFolderURL, { recursive: true });
-    const cacheFile = basename(filepath) + (isLocalImage ? "" : ".json");
+    const cacheFile = basename(filepath);
     const cachedFileURL = new URL(cacheFile, env.assetsCacheDir);
+    const cacheMetaFile = cacheFile + ".json";
+    const cachedMetaFileURL = new URL(cacheMetaFile, env.assetsCacheDir);
     try {
       if (isLocalImage) {
         await fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE);
@@ -94,15 +96,26 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
           cached: "hit"
         };
       } else {
-        const JSONData = JSON.parse(readFileSync(cachedFileURL, "utf-8"));
-        if (!JSONData.data || !JSONData.expires) {
-          await fs.promises.unlink(cachedFileURL);
+        const JSONData = JSON.parse(readFileSync(cachedMetaFileURL, "utf-8"));
+        if (!JSONData.expires) {
+          try {
+            await fs.promises.unlink(cachedFileURL);
+          } catch {
+          }
+          await fs.promises.unlink(cachedMetaFileURL);
           throw new Error(
             `Malformed cache entry for ${filepath}, cache will be regenerated for this file.`
           );
         }
+        if (JSONData.data) {
+          const { data, ...meta } = JSONData;
+          await Promise.all([
+            fs.promises.writeFile(cachedFileURL, Buffer.from(data, "base64")),
+            writeCacheMetaFile(cachedMetaFileURL, meta, env)
+          ]);
+        }
         if (JSONData.expires > Date.now()) {
-          await fs.promises.writeFile(finalFileURL, Buffer.from(JSONData.data, "base64"));
+          await fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE);
           return {
             cached: "hit"
           };
@@ -116,9 +129,12 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
             if (revalidatedData.data.length) {
               originalImage = revalidatedData;
             } else {
-              revalidatedData.data = Buffer.from(JSONData.data, "base64");
-              await writeRemoteCacheFile(cachedFileURL, revalidatedData, env);
-              await fs.promises.writeFile(finalFileURL, revalidatedData.data);
+              await writeCacheMetaFile(cachedMetaFileURL, revalidatedData, env);
+              await fs.promises.copyFile(
+                cachedFileURL,
+                finalFileURL,
+                fs.constants.COPYFILE_FICLONE
+              );
               return { cached: "revalidated" };
             }
           } catch (e) {
@@ -126,11 +142,12 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
               null,
               `An error was encountered while revalidating a cached remote asset. Proceeding with stale cache. ${e}`
             );
-            await fs.promises.writeFile(finalFileURL, Buffer.from(JSONData.data, "base64"));
+            await fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE);
             return { cached: "hit" };
           }
         }
         await fs.promises.unlink(cachedFileURL);
+        await fs.promises.unlink(cachedMetaFileURL);
       }
     } catch (e) {
       if (e.code !== "ENOENT") {
@@ -169,7 +186,10 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
         if (isLocalImage) {
           await fs.promises.writeFile(cachedFileURL, resultData.data);
         } else {
-          await writeRemoteCacheFile(cachedFileURL, resultData, env);
+          await Promise.all([
+            fs.promises.writeFile(cachedFileURL, resultData.data),
+            writeCacheMetaFile(cachedMetaFileURL, resultData, env)
+          ]);
         }
       }
     } catch (e) {
@@ -190,12 +210,11 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     };
   }
 }
-async function writeRemoteCacheFile(cachedFileURL, resultData, env) {
+async function writeCacheMetaFile(cachedMetaFileURL, resultData, env) {
   try {
     return await fs.promises.writeFile(
-      cachedFileURL,
+      cachedMetaFileURL,
       JSON.stringify({
-        data: Buffer.from(resultData.data).toString("base64"),
         expires: resultData.expires,
         etag: resultData.etag,
         lastModified: resultData.lastModified

package/dist/assets/build/remote.d.ts

@@ -1,5 +1,5 @@
 export type RemoteCacheEntry = {
-    data: string;
+    data?: string;
     expires: number;
     etag?: string;
     lastModified?: string;

package/dist/assets/vite-plugin-assets.js

@@ -70,6 +70,7 @@ function assets({ settings }) {
   globalThis.astroAsset = {
     referencedImages: /* @__PURE__ */ new Set()
   };
+  const imageComponentPrefix = settings.config.experimental.responsiveImages ? "Responsive" : "";
   return [
     // Expose the components and different utilities from `astro:assets`
     {
@@ -92,8 +93,8 @@ function assets({ settings }) {
             `
 					export { getConfiguredImageService, isLocalService } from "astro/assets";
 					import { getImage as getImageInternal } from "astro/assets";
-					export { default as Image } from "astro/components/Image.astro";
-					export { default as Picture } from "astro/components/Picture.astro";
+					export { default as Image } from "astro/components/${imageComponentPrefix}Image.astro";
+					export { default as Picture } from "astro/components/${imageComponentPrefix}Picture.astro";
 					export { inferRemoteSize } from "astro/assets/utils/inferRemoteSize.js";
 
 					export const imageConfig = ${JSON.stringify({ ...settings.config.image, experimentalResponsiveImages: settings.config.experimental.responsiveImages })};

package/dist/content/content-layer.js

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

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -36,6 +36,16 @@ import {
   globWithUnderscoresIgnored,
   isDeferredModule
 } from "./utils.js";
+function invalidateDataStore(server) {
+  const module = server.moduleGraph.getModuleById(RESOLVED_DATA_STORE_VIRTUAL_ID);
+  if (module) {
+    server.moduleGraph.invalidateModule(module);
+  }
+  server.ws.send({
+    type: "full-reload",
+    path: "*"
+  });
+}
 function astroContentVirtualModPlugin({
   settings,
   fs
@@ -49,7 +59,10 @@ function astroContentVirtualModPlugin({
       dataStoreFile = getDataStoreFile(settings, env.command === "serve");
     },
     buildStart() {
-      devServer?.watcher.add(fileURLToPath(dataStoreFile));
+      if (devServer) {
+        devServer.watcher.add(fileURLToPath(dataStoreFile));
+        invalidateDataStore(devServer);
+      }
     },
     async resolveId(id) {
       if (id === VIRTUAL_MODULE_ID) {
@@ -143,24 +156,14 @@ function astroContentVirtualModPlugin({
     configureServer(server) {
       devServer = server;
       const dataStorePath = fileURLToPath(dataStoreFile);
-      function invalidateDataStore() {
-        const module = server.moduleGraph.getModuleById(RESOLVED_DATA_STORE_VIRTUAL_ID);
-        if (module) {
-          server.moduleGraph.invalidateModule(module);
-        }
-        server.ws.send({
-          type: "full-reload",
-          path: "*"
-        });
-      }
       server.watcher.on("add", (addedPath) => {
         if (addedPath === dataStorePath) {
-          invalidateDataStore();
+          invalidateDataStore(server);
         }
       });
       server.watcher.on("change", (changedPath) => {
         if (changedPath === dataStorePath) {
-          invalidateDataStore();
+          invalidateDataStore(server);
         }
       });
     }

package/dist/core/app/index.js

@@ -89,10 +89,22 @@ class App {
     }
     return pathname;
   }
+  /**
+   * It removes the base from the request URL, prepends it with a forward slash and attempts to decoded it.
+   *
+   * If the decoding fails, it logs the error and return the pathname as is.
+   * @param request
+   * @private
+   */
   #getPathnameFromRequest(request) {
     const url = new URL(request.url);
     const pathname = prependForwardSlash(this.removeBase(url.pathname));
-    return pathname;
+    try {
+      return decodeURI(pathname);
+    } catch (e) {
+      this.getAdapterLogger().error(e.toString());
+      return pathname;
+    }
   }
   match(request) {
     const url = new URL(request.url);

package/dist/core/build/generate.js

@@ -128,7 +128,7 @@ async function generatePage(pageData, ssrEntry, builtPaths, pipeline) {
   async function generatePathWithLogs(path, route, index, paths, isConcurrent) {
     const timeStart = performance.now();
     pipeline.logger.debug("build", `Generating: ${path}`);
-    const filePath = getOutputFilename(config, path, pageData.route.type);
+    const filePath = getOutputFilename(config, path, pageData.route);
     const lineIcon = index === paths.length - 1 && !isConcurrent || paths.length === 1 ? "\u2514\u2500" : "\u251C\u2500";
     if (!isConcurrent) {
       logger.info(null, `  ${blue(lineIcon)} ${dim(filePath)}`, false);

package/dist/core/build/static-build.js

@@ -272,7 +272,7 @@ async function cleanServerOutput(opts, ssrOutputChunkNames, internals) {
       files.map(async (filename) => {
         const url = new URL(filename, out);
         const map = new URL(url + ".map");
-        await Promise.all([fs.promises.rm(url), fs.promises.rm(new URL(map)).catch((e) => {
+        await Promise.all([fs.promises.rm(url), fs.promises.rm(map).catch(() => {
         })]);
       })
     );

package/dist/core/config/schema.d.ts

@@ -1,5 +1,5 @@
-import type { ShikiConfig, RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype } from '@astrojs/markdown-remark';
 import type { OutgoingHttpHeaders } from 'node:http';
+import type { ShikiConfig, RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype } from '@astrojs/markdown-remark';
 import { z } from 'zod';
 import type { ViteUserConfig } from '../../types/public/config.js';
 interface ComplexifyUnionObj {
@@ -449,34 +449,43 @@ export declare const AstroConfigSchema: z.ZodObject<{
         checkOrigin?: boolean | undefined;
     }>>>;
     env: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        schema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, z.ZodIntersection<z.ZodUnion<[z.ZodObject<{
-            context: z.ZodLiteral<"client">;
-            access: z.ZodLiteral<"public">;
-        }, "strip", z.ZodTypeAny, {
+        schema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, z.ZodIntersection<z.ZodEffects<z.ZodType<{
             context: "client";
             access: "public";
-        }, {
+        } | {
+            context: "server";
+            access: "public";
+        } | {
+            context: "server";
+            access: "secret";
+        }, z.ZodTypeDef, {
             context: "client";
             access: "public";
-        }>, z.ZodObject<{
-            context: z.ZodLiteral<"server">;
-            access: z.ZodLiteral<"public">;
-        }, "strip", z.ZodTypeAny, {
+        } | {
             context: "server";
             access: "public";
-        }, {
+        } | {
             context: "server";
+            access: "secret";
+        }>, {
+            context: "client";
             access: "public";
-        }>, z.ZodObject<{
-            context: z.ZodLiteral<"server">;
-            access: z.ZodLiteral<"secret">;
-        }, "strip", z.ZodTypeAny, {
+        } | {
+            context: "server";
+            access: "public";
+        } | {
             context: "server";
             access: "secret";
         }, {
+            context: "client";
+            access: "public";
+        } | {
+            context: "server";
+            access: "public";
+        } | {
             context: "server";
             access: "secret";
-        }>]>, z.ZodUnion<[z.ZodObject<{
+        }>, z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"string">;
             optional: z.ZodOptional<z.ZodBoolean>;
             default: z.ZodOptional<z.ZodString>;
@@ -1507,34 +1516,43 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         checkOrigin?: boolean | undefined;
     }>>>;
     env: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        schema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, z.ZodIntersection<z.ZodUnion<[z.ZodObject<{
-            context: z.ZodLiteral<"client">;
-            access: z.ZodLiteral<"public">;
-        }, "strip", z.ZodTypeAny, {
+        schema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, z.ZodIntersection<z.ZodEffects<z.ZodType<{
             context: "client";
             access: "public";
-        }, {
+        } | {
+            context: "server";
+            access: "public";
+        } | {
+            context: "server";
+            access: "secret";
+        }, z.ZodTypeDef, {
             context: "client";
             access: "public";
-        }>, z.ZodObject<{
-            context: z.ZodLiteral<"server">;
-            access: z.ZodLiteral<"public">;
-        }, "strip", z.ZodTypeAny, {
+        } | {
             context: "server";
             access: "public";
-        }, {
+        } | {
             context: "server";
+            access: "secret";
+        }>, {
+            context: "client";
             access: "public";
-        }>, z.ZodObject<{
-            context: z.ZodLiteral<"server">;
-            access: z.ZodLiteral<"secret">;
-        }, "strip", z.ZodTypeAny, {
+        } | {
+            context: "server";
+            access: "public";
+        } | {
             context: "server";
             access: "secret";
         }, {
+            context: "client";
+            access: "public";
+        } | {
+            context: "server";
+            access: "public";
+        } | {
             context: "server";
             access: "secret";
-        }>]>, z.ZodUnion<[z.ZodObject<{
+        }>, z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"string">;
             optional: z.ZodOptional<z.ZodBoolean>;
             default: z.ZodOptional<z.ZodString>;

package/dist/core/config/schema.js

@@ -1,7 +1,7 @@
-import { markdownConfigDefaults } from "@astrojs/markdown-remark";
-import { bundledThemes } from "shiki";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { markdownConfigDefaults } from "@astrojs/markdown-remark";
+import { bundledThemes } from "shiki";
 import { z } from "zod";
 import { EnvSchema } from "../../env/schema.js";
 import { appendForwardSlash, prependForwardSlash, removeTrailingForwardSlash } from "../path.js";

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "5.1.3";
+const ASTRO_VERSION = "5.1.4";
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
 const REWRITE_DIRECTIVE_HEADER_VALUE = "yes";

package/dist/core/dev/dev.js

@@ -22,7 +22,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "5.1.3";
+  const currentVersion = "5.1.4";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/messages.js

@@ -38,7 +38,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "5.1.3";
+  const version = "5.1.4";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -276,7 +276,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"5.1.3"}`
+        `v${"5.1.4"}`
       )} ${headline}`
     );
   }

package/dist/core/middleware/sequence.js

@@ -39,7 +39,11 @@ function sequence(...handlers) {
             if (pipeline.serverLike === true && handleContext.isPrerendered === false && routeData.prerender === true) {
               throw new AstroError({
                 ...ForbiddenRewrite,
-                message: ForbiddenRewrite.message(pathname, pathname, routeData.component),
+                message: ForbiddenRewrite.message(
+                  handleContext.url.pathname,
+                  pathname,
+                  routeData.component
+                ),
                 hint: ForbiddenRewrite.hint(routeData.component)
               });
             }

package/dist/core/render/params-and-props.js

@@ -19,7 +19,7 @@ async function getProps(opts) {
     ssr: serverLike,
     base
   });
-  const params = getParams(route, decodeURI(pathname));
+  const params = getParams(route, pathname);
   const matchedStaticPath = findPathItemByKey(staticPaths, params, route, logger);
   if (!matchedStaticPath && (serverLike ? route.prerender : true)) {
     throw new AstroError({

package/dist/core/render-context.js

@@ -72,7 +72,7 @@ class RenderContext {
       pipeline,
       locals,
       sequence(...pipeline.internalMiddleware, middleware ?? pipelineMiddleware),
-      decodeURI(pathname),
+      pathname,
       request,
       routeData,
       status,
@@ -137,7 +137,14 @@ class RenderContext {
         if (payload instanceof Request) {
           this.request = payload;
         } else {
-          this.request = copyRequest(newUrl, this.request);
+          this.request = copyRequest(
+            newUrl,
+            this.request,
+            // need to send the flag of the previous routeData
+            routeData.prerender,
+            this.pipeline.logger,
+            this.routeData.route
+          );
         }
         this.isRewriting = true;
         this.url = new URL(this.request.url);
@@ -228,7 +235,14 @@ class RenderContext {
     if (reroutePayload instanceof Request) {
       this.request = reroutePayload;
     } else {
-      this.request = copyRequest(newUrl, this.request);
+      this.request = copyRequest(
+        newUrl,
+        this.request,
+        // need to send the flag of the previous routeData
+        routeData.prerender,
+        this.pipeline.logger,
+        this.routeData.route
+      );
     }
     this.url = new URL(this.request.url);
     this.cookies = new AstroCookies(this.request);

package/dist/core/request.d.ts

@@ -1,13 +1,13 @@
 import type { IncomingHttpHeaders } from 'node:http';
 import type { Logger } from './logger/core.js';
 type HeaderType = Headers | Record<string, any> | IncomingHttpHeaders;
-type RequestBody = ArrayBuffer | Blob | ReadableStream | URLSearchParams | FormData;
+type RequestBody = ArrayBuffer | Blob | ReadableStream | URLSearchParams | FormData | ReadableStream<Uint8Array>;
 export interface CreateRequestOptions {
     url: URL | string;
     clientAddress?: string | undefined;
     headers: HeaderType;
     method?: string;
-    body?: RequestBody | undefined;
+    body?: RequestBody | undefined | null;
     logger: Logger;
     locals?: object | undefined;
     /**
@@ -19,6 +19,7 @@ export interface CreateRequestOptions {
      */
     isPrerendered?: boolean;
     routePattern: string;
+    init?: RequestInit;
 }
 /**
  * Used by astro internals to create a web standard request object.
@@ -27,5 +28,5 @@ export interface CreateRequestOptions {
  *
  * This is used by the static build to create fake requests for prerendering, and by the dev server to convert node requests into the standard request object.
  */
-export declare function createRequest({ url, headers, method, body, logger, isPrerendered, routePattern, }: CreateRequestOptions): Request;
+export declare function createRequest({ url, headers, method, body, logger, isPrerendered, routePattern, init, }: CreateRequestOptions): Request;
 export {};

package/dist/core/request.js

@@ -5,7 +5,8 @@ function createRequest({
   body = void 0,
   logger,
   isPrerendered = false,
-  routePattern
+  routePattern,
+  init
 }) {
   const headersObj = isPrerendered ? void 0 : headers instanceof Headers ? headers : new Headers(
     // Filter out HTTP/2 pseudo-headers. These are internally-generated headers added to all HTTP/2 requests with trusted metadata about the request.
@@ -22,7 +23,8 @@ function createRequest({
     method,
     headers: headersObj,
     // body is made available only if the request is for a page that will be on-demand rendered
-    body: isPrerendered ? null : body
+    body: isPrerendered ? null : body,
+    ...init
   });
   if (isPrerendered) {
     let _headers = request.headers;

package/dist/core/routing/rewrite.d.ts

@@ -1,6 +1,7 @@
 import type { RewritePayload } from '../../types/public/common.js';
 import type { AstroConfig } from '../../types/public/config.js';
 import type { RouteData } from '../../types/public/internal.js';
+import type { Logger } from '../logger/core.js';
 export type FindRouteToRewrite = {
     payload: RewritePayload;
     routes: RouteData[];
@@ -25,7 +26,10 @@ export declare function findRouteToRewrite({ payload, routes, request, trailingS
  *
  * @param newUrl The new `URL`
  * @param oldRequest The old `Request`
+ * @param isPrerendered It needs to be the flag of the previous routeData, before the rewrite
+ * @param logger
+ * @param routePattern
  */
-export declare function copyRequest(newUrl: URL, oldRequest: Request): Request;
+export declare function copyRequest(newUrl: URL, oldRequest: Request, isPrerendered: boolean, logger: Logger, routePattern: string): Request;
 export declare function setOriginPathname(request: Request, pathname: string): void;
 export declare function getOriginPathname(request: Request): string;

package/dist/core/routing/rewrite.js

@@ -2,6 +2,7 @@ import { shouldAppendForwardSlash } from "../build/util.js";
 import { originPathnameSymbol } from "../constants.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { appendForwardSlash, removeTrailingForwardSlash } from "../path.js";
+import { createRequest } from "../request.js";
 import { DEFAULT_404_ROUTE } from "./astro-designed-error-pages.js";
 function findRouteToRewrite({
   payload,
@@ -46,26 +47,32 @@ function findRouteToRewrite({
     }
   }
 }
-function copyRequest(newUrl, oldRequest) {
+function copyRequest(newUrl, oldRequest, isPrerendered, logger, routePattern) {
   if (oldRequest.bodyUsed) {
     throw new AstroError(AstroErrorData.RewriteWithBodyUsed);
   }
-  return new Request(newUrl, {
+  return createRequest({
+    url: newUrl,
     method: oldRequest.method,
-    headers: oldRequest.headers,
     body: oldRequest.body,
-    referrer: oldRequest.referrer,
-    referrerPolicy: oldRequest.referrerPolicy,
-    mode: oldRequest.mode,
-    credentials: oldRequest.credentials,
-    cache: oldRequest.cache,
-    redirect: oldRequest.redirect,
-    integrity: oldRequest.integrity,
-    signal: oldRequest.signal,
-    keepalive: oldRequest.keepalive,
-    // https://fetch.spec.whatwg.org/#dom-request-duplex
-    // @ts-expect-error It isn't part of the types, but undici accepts it and it allows to carry over the body to a new request
-    duplex: "half"
+    isPrerendered,
+    logger,
+    headers: isPrerendered ? {} : oldRequest.headers,
+    routePattern,
+    init: {
+      referrer: oldRequest.referrer,
+      referrerPolicy: oldRequest.referrerPolicy,
+      mode: oldRequest.mode,
+      credentials: oldRequest.credentials,
+      cache: oldRequest.cache,
+      redirect: oldRequest.redirect,
+      integrity: oldRequest.integrity,
+      signal: oldRequest.signal,
+      keepalive: oldRequest.keepalive,
+      // https://fetch.spec.whatwg.org/#dom-request-duplex
+      // @ts-expect-error It isn't part of the types, but undici accepts it and it allows to carry over the body to a new request
+      duplex: "half"
+    }
   });
 }
 function setOriginPathname(request, pathname) {

package/dist/core/util.d.ts

@@ -1,6 +1,6 @@
 import type { AstroSettings } from '../types/astro.js';
 import type { AstroConfig } from '../types/public/config.js';
-import type { RouteType } from '../types/public/internal.js';
+import type { RouteData } from '../types/public/internal.js';
 /** Returns true if argument is an object of any prototype/class (but not null). */
 export declare function isObject(value: unknown): value is Record<string, any>;
 /** Cross-realm compatible URL */
@@ -17,7 +17,7 @@ export declare function padMultilineString(source: string, n?: number): string;
  * Handles both "/foo" and "foo" `name` formats.
  * Handles `/404` and `/` correctly.
  */
-export declare function getOutputFilename(astroConfig: AstroConfig, name: string, type: RouteType): string;
+export declare function getOutputFilename(astroConfig: AstroConfig, name: string, routeData: RouteData): string;
 /** is a specifier an npm package? */
 export declare function parseNpmName(spec: string): {
     scope?: string;

package/dist/core/util.js

@@ -26,8 +26,8 @@ function padMultilineString(source, n = 2) {
 `);
 }
 const STATUS_CODE_PAGES = /* @__PURE__ */ new Set(["/404", "/500"]);
-function getOutputFilename(astroConfig, name, type) {
-  if (type === "endpoint") {
+function getOutputFilename(astroConfig, name, routeData) {
+  if (routeData.type === "endpoint") {
     return name;
   }
   if (name === "/" || name === "") {
@@ -36,6 +36,9 @@ function getOutputFilename(astroConfig, name, type) {
   if (astroConfig.build.format === "file" || STATUS_CODE_PAGES.has(name)) {
     return `${removeTrailingForwardSlash(name || "index")}.html`;
   }
+  if (astroConfig.build.format === "preserve" && !routeData.isIndex) {
+    return `${removeTrailingForwardSlash(name || "index")}.html`;
+  }
   return path.posix.join(name, "index.html");
 }
 function parseNpmName(spec) {

package/dist/env/schema.d.ts

@@ -192,62 +192,80 @@ declare const EnvFieldType: z.ZodUnion<[z.ZodObject<{
     optional?: boolean | undefined;
 }>]>;
 export type EnvFieldType = z.infer<typeof EnvFieldType>;
-declare const EnvFieldMetadata: z.ZodUnion<[z.ZodObject<{
-    context: z.ZodLiteral<"client">;
-    access: z.ZodLiteral<"public">;
-}, "strip", z.ZodTypeAny, {
+declare const EnvFieldMetadata: z.ZodEffects<z.ZodType<{
     context: "client";
     access: "public";
-}, {
+} | {
+    context: "server";
+    access: "public";
+} | {
+    context: "server";
+    access: "secret";
+}, z.ZodTypeDef, {
     context: "client";
     access: "public";
-}>, z.ZodObject<{
-    context: z.ZodLiteral<"server">;
-    access: z.ZodLiteral<"public">;
-}, "strip", z.ZodTypeAny, {
+} | {
     context: "server";
     access: "public";
-}, {
+} | {
     context: "server";
+    access: "secret";
+}>, {
+    context: "client";
     access: "public";
-}>, z.ZodObject<{
-    context: z.ZodLiteral<"server">;
-    access: z.ZodLiteral<"secret">;
-}, "strip", z.ZodTypeAny, {
+} | {
+    context: "server";
+    access: "public";
+} | {
     context: "server";
     access: "secret";
 }, {
+    context: "client";
+    access: "public";
+} | {
+    context: "server";
+    access: "public";
+} | {
     context: "server";
     access: "secret";
-}>]>;
-export declare const EnvSchema: z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, z.ZodIntersection<z.ZodUnion<[z.ZodObject<{
-    context: z.ZodLiteral<"client">;
-    access: z.ZodLiteral<"public">;
-}, "strip", z.ZodTypeAny, {
+}>;
+export declare const EnvSchema: z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, z.ZodIntersection<z.ZodEffects<z.ZodType<{
     context: "client";
     access: "public";
-}, {
+} | {
+    context: "server";
+    access: "public";
+} | {
+    context: "server";
+    access: "secret";
+}, z.ZodTypeDef, {
     context: "client";
     access: "public";
-}>, z.ZodObject<{
-    context: z.ZodLiteral<"server">;
-    access: z.ZodLiteral<"public">;
-}, "strip", z.ZodTypeAny, {
+} | {
     context: "server";
     access: "public";
-}, {
+} | {
     context: "server";
+    access: "secret";
+}>, {
+    context: "client";
     access: "public";
-}>, z.ZodObject<{
-    context: z.ZodLiteral<"server">;
-    access: z.ZodLiteral<"secret">;
-}, "strip", z.ZodTypeAny, {
+} | {
+    context: "server";
+    access: "public";
+} | {
     context: "server";
     access: "secret";
 }, {
+    context: "client";
+    access: "public";
+} | {
+    context: "server";
+    access: "public";
+} | {
     context: "server";
     access: "secret";
-}>]>, z.ZodUnion<[z.ZodObject<{
+}>, z.ZodUnion<[z.ZodObject<{
     type: z.ZodLiteral<"string">;
     optional: z.ZodOptional<z.ZodBoolean>;
     default: z.ZodOptional<z.ZodString>;

package/dist/env/schema.js

@@ -64,11 +64,30 @@ const SecretServerEnvFieldMetadata = z.object({
   context: z.literal("server"),
   access: z.literal("secret")
 });
-const EnvFieldMetadata = z.union([
+const _EnvFieldMetadata = z.union([
   PublicClientEnvFieldMetadata,
   PublicServerEnvFieldMetadata,
   SecretServerEnvFieldMetadata
 ]);
+const EnvFieldMetadata = z.custom().superRefine((data, ctx) => {
+  const result = _EnvFieldMetadata.safeParse(data);
+  if (result.success) {
+    return;
+  }
+  for (const issue of result.error.issues) {
+    if (issue.code === z.ZodIssueCode.invalid_union) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `**Invalid combination** of "access" and "context" options:
+  Secret client variables are not supported. Please review the configuration of \`env.schema.${ctx.path.at(-1)}\`.
+  Learn more at https://docs.astro.build/en/guides/environment-variables/#variable-types`,
+        path: ["context", "access"]
+      });
+    } else {
+      ctx.addIssue(issue);
+    }
+  }
+});
 const EnvSchemaKey = z.string().min(1).refine(([firstChar]) => isNaN(Number.parseInt(firstChar)), {
   message: "A valid variable name cannot start with a number."
 }).refine((str) => /^[A-Z0-9_]+$/.test(str), {

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

@@ -12,8 +12,8 @@ async function compileAstro({
   try {
     transformResult = await compile(compileProps);
     esbuildResult = await transformWithEsbuild(transformResult.code, compileProps.filename, {
+      ...compileProps.viteConfig.esbuild,
       loader: "ts",
-      target: "esnext",
       sourcemap: "external",
       tsconfigRaw: {
         compilerOptions: {

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

@@ -17,7 +17,7 @@ async function handleRequest({
   if (config.trailingSlash === "never" && !incomingRequest.url) {
     pathname = "";
   } else {
-    pathname = url.pathname;
+    pathname = decodeURI(url.pathname);
   }
   url.pathname = removeTrailingForwardSlash(config.base) + url.pathname;
   let body = void 0;

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

@@ -179,7 +179,7 @@ async function handleRoute({
     const fourOhFourRoute = await matchRoute("/404", manifestData, pipeline);
     if (fourOhFourRoute) {
       renderContext = await RenderContext.create({
-        locals: {},
+        locals,
         pipeline,
         pathname,
         middleware: isDefaultPrerendered404(fourOhFourRoute.route) ? void 0 : middleware,

package/dist/vite-plugin-markdown/content-entry-type.js

@@ -17,12 +17,7 @@ const markdownContentEntryType = {
   async getRenderFunction(config) {
     const processor = await createMarkdownProcessor(config.markdown);
     return async function renderToString(entry) {
-      if (!entry.body) {
-        return {
-          html: ""
-        };
-      }
-      const result = await processor.render(entry.body, {
+      const result = await processor.render(entry.body ?? "", {
         frontmatter: entry.data,
         // @ts-expect-error Internal API
         fileURL: entry.filePath ? pathToFileURL(entry.filePath) : void 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "5.1.3",
+  "version": "5.1.4",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",