astro 6.0.0-beta.17 → 6.0.0-beta.18

package/dist/actions/runtime/types.d.ts

@@ -49,7 +49,7 @@ export interface ActionsLocals {
         actionName: string;
     };
 }
-export type ActionAPIContext = Pick<APIContext, 'request' | 'url' | 'isPrerendered' | 'locals' | 'clientAddress' | 'cookies' | 'currentLocale' | 'generator' | 'routePattern' | 'site' | 'params' | 'preferredLocale' | 'preferredLocaleList' | 'originPathname' | 'session' | 'csp'>;
+export type ActionAPIContext = Pick<APIContext, 'request' | 'url' | 'isPrerendered' | 'locals' | 'clientAddress' | 'cookies' | 'currentLocale' | 'generator' | 'routePattern' | 'site' | 'params' | 'preferredLocale' | 'preferredLocaleList' | 'originPathname' | 'session' | 'cache' | 'csp'>;
 export type MaybePromise<T> = T | Promise<T>;
 /**
  * Used to preserve the input schema type in the error object.

package/dist/assets/utils/proxy.js

@@ -9,7 +9,7 @@ function getProxyCode(options, isSSR) {
 							if (name === 'fsPath') {
 								return ${stringifiedFSPath};
 							}
-							${!isSSR ? `if (target[name] !== undefined && globalThis.astroAsset) globalThis.astroAsset?.referencedImages.add(${stringifiedFSPath});` : ""}
+							${!isSSR ? `if (target[name] !== undefined && globalThis.astroAsset) globalThis.astroAsset?.referencedImages?.add(${stringifiedFSPath});` : ""}
 							return target[name];
 						}
 					})

package/dist/assets/utils/svg.js

@@ -49,6 +49,16 @@ function makeSvgComponent(meta, contents, svgoConfig) {
   return `import { createSvgComponent } from 'astro/assets/runtime';
 export default createSvgComponent(${JSON.stringify(props)})`;
 }
+function parseSvgComponentData(meta, contents, svgoConfig) {
+  const file = typeof contents === "string" ? contents : contents.toString("utf-8");
+  const { attributes, body: children } = parseSvg({
+    path: meta.fsPath,
+    contents: file,
+    svgoConfig
+  });
+  return { attributes: dropAttributes(attributes), children };
+}
 export {
-  makeSvgComponent
+  makeSvgComponent,
+  parseSvgComponentData
 };

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

@@ -29,7 +29,7 @@ import { hashTransform, propsToFilename } from "./utils/hash.js";
 import { emitImageMetadata } from "./utils/node.js";
 import { CONTENT_IMAGE_FLAG } from "../content/consts.js";
 import { getProxyCode } from "./utils/proxy.js";
-import { makeSvgComponent } from "./utils/svg.js";
+import { makeSvgComponent, parseSvgComponentData } from "./utils/svg.js";
 import { createPlaceholderURL, stringifyPlaceholderURL } from "./utils/url.js";
 const assetRegex = new RegExp(`\\.(${VALID_INPUT_FORMATS.join("|")})`, "i");
 const assetRegexEnds = new RegExp(`\\.(${VALID_INPUT_FORMATS.join("|")})$`, "i");
@@ -252,6 +252,20 @@ function assets({ fs, settings, sync, logger }) {
             if (isSSROnlyEnvironment) {
               globalThis.astroAsset.referencedImages.add(imageMetadata.fsPath);
             }
+            if (id.endsWith(".svg") && isContentImage) {
+              const contents = await fs.promises.readFile(imageMetadata.fsPath, {
+                encoding: "utf8"
+              });
+              const svgData = parseSvgComponentData(
+                imageMetadata,
+                contents,
+                settings.config.experimental.svgo
+              );
+              const metadataWithSvg = { ...imageMetadata, __svgData: svgData };
+              return {
+                code: `export default ${getProxyCode(metadataWithSvg, isSSROnlyEnvironment)}`
+              };
+            }
             return {
               code: `export default ${getProxyCode(imageMetadata, isSSROnlyEnvironment)}`
             };

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.0-beta.17";
+  version = "6.0.0-beta.18";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/config/entrypoint.d.ts

@@ -1,4 +1,6 @@
 import type { SharpImageServiceConfig } from '../assets/services/sharp.js';
+import type { MemoryCacheProviderOptions } from '../core/cache/memory-provider.js';
+import type { CacheProviderConfig } from '../core/cache/types.js';
 import type { ImageServiceConfig } from '../types/public/index.js';
 export { fontProviders } from '../assets/fonts/providers/index.js';
 export { mergeConfig } from '../core/config/merge.js';
@@ -17,3 +19,8 @@ export declare function sharpImageService(config?: SharpImageServiceConfig): Ima
  * See: https://docs.astro.build/en/guides/images/#configure-no-op-passthrough-service
  */
 export declare function passthroughImageService(): ImageServiceConfig;
+/**
+ * Return the configuration needed to use the built-in in-memory LRU cache provider.
+ * This is a runtime-agnostic provider suitable for single-instance deployments.
+ */
+export declare function memoryCache(config?: MemoryCacheProviderOptions): CacheProviderConfig<MemoryCacheProviderOptions>;

package/dist/config/entrypoint.js

@@ -16,11 +16,19 @@ function passthroughImageService() {
     config: {}
   };
 }
+function memoryCache(config = {}) {
+  return {
+    name: "memory",
+    entrypoint: "astro/cache/memory",
+    config
+  };
+}
 export {
   defineConfig,
   envField,
   fontProviders,
   getViteConfig,
+  memoryCache,
   mergeConfig,
   passthroughImageService,
   sessionDrivers,

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.0-beta.17") {
+    if (previousAstroVersion && previousAstroVersion !== "6.0.0-beta.18") {
       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.0-beta.17") {
-      this.#store.metaStore().set("astro-version", "6.0.0-beta.17");
+    if ("6.0.0-beta.18") {
+      this.#store.metaStore().set("astro-version", "6.0.0-beta.18");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/content/runtime.js

@@ -1,6 +1,7 @@
 import { escape } from "html-escaper";
 import { Traverse } from "neotraverse/modern";
 import * as z from "zod/v4";
+import { createSvgComponent } from "../assets/runtime.js";
 import { imageSrcToImportId } from "../assets/utils/resolveImports.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { isRemotePath, prependForwardSlash } from "../core/path.js";
@@ -363,7 +364,12 @@ function updateImageReferencesInData(data, fileName, imageAssetMap) {
       }
       const imported = imageAssetMap?.get(id);
       if (imported) {
-        ctx.update(imported);
+        if (imported.__svgData) {
+          const { __svgData: svgData, ...meta } = imported;
+          ctx.update(createSvgComponent({ meta, ...svgData }));
+        } else {
+          ctx.update(imported);
+        }
       } else {
         ctx.update(src);
       }

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

@@ -60,10 +60,12 @@ function astroContentAssetPropagationPlugin({
       }
     },
     configureServer(server) {
-      if (!isRunnableDevEnvironment(server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr])) {
-        return;
+      const ssrEnv = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      if (isRunnableDevEnvironment(ssrEnv)) {
+        environment = ssrEnv;
+      } else if (isRunnableDevEnvironment(server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.astro])) {
+        environment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.astro];
       }
-      environment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
     },
     transform: {
       filter: {
@@ -75,7 +77,8 @@ function astroContentAssetPropagationPlugin({
           let stringifiedLinks, stringifiedStyles;
           if (isAstroServerEnvironment(this.environment) && environment) {
             if (!environment.moduleGraph.getModuleById(basePath)?.ssrModule) {
-              await environment.runner.import(basePath);
+              await environment.runner.import(basePath).catch(() => {
+              });
             }
             const {
               styles,

package/dist/core/app/base.d.ts

@@ -51,9 +51,15 @@ export interface RenderOptions {
      */
     routeData?: RouteData;
 }
-export interface RenderErrorOptions {
-    locals?: App.Locals;
-    routeData?: RouteData;
+type RequiredRenderOptions = Required<RenderOptions>;
+interface ResolvedRenderOptions {
+    addCookieHeader: RequiredRenderOptions['addCookieHeader'];
+    clientAddress: RequiredRenderOptions['clientAddress'] | undefined;
+    prerenderedErrorPageFetch: RequiredRenderOptions['prerenderedErrorPageFetch'] | undefined;
+    locals: RequiredRenderOptions['locals'] | undefined;
+    routeData: RequiredRenderOptions['routeData'] | undefined;
+}
+export interface RenderErrorOptions extends ResolvedRenderOptions {
     response?: Response;
     status: 404 | 500;
     /**
@@ -64,8 +70,6 @@ export interface RenderErrorOptions {
      * Allows passing an error to 500.astro. It will be available through `Astro.props.error`.
      */
     error?: unknown;
-    clientAddress: string | undefined;
-    prerenderedErrorPageFetch: ((url: ErrorPagePath) => Promise<Response>) | undefined;
 }
 type ErrorPagePath = `${string}/404` | `${string}/500` | `${string}/404/` | `${string}/500/` | `${string}404.html` | `${string}500.html`;
 export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
@@ -120,7 +124,7 @@ export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
     devMatch(pathname?: string): Promise<DevMatch | undefined> | undefined;
     private computePathnameFromDomain;
     private redirectTrailingSlash;
-    render(request: Request, renderOptions?: RenderOptions): Promise<Response>;
+    render(request: Request, { addCookieHeader, clientAddress, locals, prerenderedErrorPageFetch, routeData, }?: RenderOptions): Promise<Response>;
     setCookieHeaders(response: Response): Generator<string, string[], any>;
     /**
      * Reads all the cookies written by `Astro.cookie.set()` onto the passed response.
@@ -138,7 +142,7 @@ export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
      * If it is a known error code, try sending the according page (e.g. 404.astro / 500.astro).
      * This also handles pre-rendered /404 or /500 routes
      */
-    renderError(request: Request, { locals, status, response: originalResponse, skipMiddleware, error, clientAddress, prerenderedErrorPageFetch, }: RenderErrorOptions): Promise<Response>;
+    renderError(request: Request, { status, response: originalResponse, skipMiddleware, error, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;
     private mergeResponses;
     getDefaultStatusCode(routeData: RouteData, pathname: string): number;
     getManifest(): SSRManifest;

package/dist/core/app/base.js

@@ -1,5 +1,6 @@
 import {
   appendForwardSlash,
+  collapseDuplicateLeadingSlashes,
   collapseDuplicateTrailingSlashes,
   hasFileExtension,
   isInternalPath,
@@ -12,12 +13,19 @@ import { normalizeTheLocale } from "../../i18n/index.js";
 import {
   clientAddressSymbol,
   DEFAULT_404_COMPONENT,
+  NOOP_MIDDLEWARE_HEADER,
   REROUTABLE_STATUS_CODES,
   REROUTE_DIRECTIVE_HEADER,
   responseSentSymbol,
-  REWRITE_DIRECTIVE_HEADER_KEY
+  REWRITE_DIRECTIVE_HEADER_KEY,
+  ROUTE_TYPE_HEADER
 } from "../constants.js";
-import { getSetCookiesFromResponse } from "../cookies/index.js";
+import {
+  AstroCookies,
+  attachCookiesToResponse,
+  getSetCookiesFromResponse
+} from "../cookies/index.js";
+import { getCookiesFromResponse } from "../cookies/response.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { consoleLogDestination } from "../logger/console.js";
 import { AstroIntegrationLogger, Logger } from "../logger/core.js";
@@ -25,6 +33,7 @@ import { RenderContext } from "../render-context.js";
 import { redirectTemplate } from "../routing/3xx.js";
 import { ensure404Route } from "../routing/astro-designed-error-pages.js";
 import { matchRoute } from "../routing/match.js";
+import { applyCacheHeaders } from "../cache/runtime/cache.js";
 import { Router } from "../routing/router.js";
 import { PERSIST_SYMBOL } from "../session/runtime.js";
 class BaseApp {
@@ -78,6 +87,7 @@ class BaseApp {
     this.#router = this.createRouter(this.manifestData);
   }
   removeBase(pathname) {
+    pathname = collapseDuplicateLeadingSlashes(pathname);
     if (pathname.startsWith(this.manifest.base)) {
       return pathname.slice(this.baseWithoutTrailingSlash.length + 1);
     }
@@ -208,18 +218,19 @@ class BaseApp {
     }
     return pathname;
   }
-  async render(request, renderOptions) {
+  async render(request, {
+    addCookieHeader = false,
+    clientAddress = Reflect.get(request, clientAddressSymbol),
+    locals,
+    prerenderedErrorPageFetch = fetch,
+    routeData
+  } = {}) {
     const timeStart = performance.now();
-    let routeData = renderOptions?.routeData;
-    let locals;
-    let clientAddress;
-    let addCookieHeader;
     const url = new URL(request.url);
     const redirect = this.redirectTrailingSlash(url.pathname);
-    const prerenderedErrorPageFetch = renderOptions?.prerenderedErrorPageFetch ?? fetch;
     if (redirect !== url.pathname) {
       const status = request.method === "GET" ? 301 : 308;
-      return new Response(
+      const response2 = new Response(
         redirectTemplate({
           status,
           relativeLocation: url.pathname,
@@ -233,11 +244,9 @@ class BaseApp {
           }
         }
       );
+      this.#prepareResponse(response2, { addCookieHeader });
+      return response2;
     }
-    addCookieHeader = renderOptions?.addCookieHeader;
-    clientAddress = renderOptions?.clientAddress ?? Reflect.get(request, clientAddressSymbol);
-    routeData = renderOptions?.routeData;
-    locals = renderOptions?.locals;
     if (routeData) {
       this.logger.debug(
         "router",
@@ -247,15 +256,24 @@ class BaseApp {
       this.logger.debug("router", "RouteData");
       this.logger.debug("router", routeData);
     }
+    const resolvedRenderOptions = {
+      addCookieHeader,
+      clientAddress,
+      prerenderedErrorPageFetch,
+      locals,
+      routeData
+    };
     if (locals) {
       if (typeof locals !== "object") {
         const error = new AstroError(AstroErrorData.LocalsNotAnObject);
         this.logger.error(null, error.stack);
         return this.renderError(request, {
+          ...resolvedRenderOptions,
+          // If locals are invalid, we don't want to include them when
+          // rendering the error page
+          locals: void 0,
           status: 500,
-          error,
-          clientAddress,
-          prerenderedErrorPageFetch
+          error
         });
       }
     }
@@ -280,16 +298,15 @@ class BaseApp {
       this.logger.debug("router", "Astro hasn't found routes that match " + request.url);
       this.logger.debug("router", "Here's the available routes:\n", this.manifestData);
       return this.renderError(request, {
-        locals,
-        status: 404,
-        clientAddress,
-        prerenderedErrorPageFetch
+        ...resolvedRenderOptions,
+        status: 404
       });
     }
     const pathname = this.getPathnameFromRequest(request);
     const defaultStatus = this.getDefaultStatusCode(routeData, pathname);
     let response;
     let session;
+    let cache;
     try {
       const componentInstance = await this.pipeline.getComponentByRoute(routeData);
       const renderContext = await this.createRenderContext({
@@ -302,7 +319,30 @@ class BaseApp {
         clientAddress
       });
       session = renderContext.session;
-      response = await renderContext.render(componentInstance);
+      cache = renderContext.cache;
+      if (this.pipeline.cacheProvider) {
+        const cacheProvider = await this.pipeline.getCacheProvider();
+        if (cacheProvider?.onRequest) {
+          response = await cacheProvider.onRequest(
+            {
+              request,
+              url: new URL(request.url)
+            },
+            async () => {
+              const res = await renderContext.render(componentInstance);
+              applyCacheHeaders(cache, res);
+              return res;
+            }
+          );
+          response.headers.delete("CDN-Cache-Control");
+          response.headers.delete("Cache-Tag");
+        } else {
+          response = await renderContext.render(componentInstance);
+          applyCacheHeaders(cache, response);
+        }
+      } else {
+        response = await renderContext.render(componentInstance);
+      }
       const isRewrite = response.headers.has(REWRITE_DIRECTIVE_HEADER_KEY);
       this.logThisRequest({
         pathname,
@@ -314,11 +354,9 @@ class BaseApp {
     } catch (err) {
       this.logger.error(null, err.stack || err.message || String(err));
       return this.renderError(request, {
-        locals,
+        ...resolvedRenderOptions,
         status: 500,
-        error: err,
-        clientAddress,
-        prerenderedErrorPageFetch
+        error: err
       });
     } finally {
       await session?.[PERSIST_SYMBOL]();
@@ -327,26 +365,34 @@ class BaseApp {
     // but uses the current route to handle the 404
     response.body === null && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
       return this.renderError(request, {
-        locals,
+        ...resolvedRenderOptions,
         response,
         status: response.status,
         // We don't have an error to report here. Passing null means we pass nothing intentionally
         // while undefined means there's no error
-        error: response.status === 500 ? null : void 0,
-        clientAddress,
-        prerenderedErrorPageFetch
+        error: response.status === 500 ? null : void 0
       });
     }
-    if (response.headers.has(REROUTE_DIRECTIVE_HEADER)) {
-      response.headers.delete(REROUTE_DIRECTIVE_HEADER);
+    this.#prepareResponse(response, { addCookieHeader });
+    return response;
+  }
+  #prepareResponse(response, { addCookieHeader }) {
+    for (const headerName of [
+      REROUTE_DIRECTIVE_HEADER,
+      REWRITE_DIRECTIVE_HEADER_KEY,
+      NOOP_MIDDLEWARE_HEADER,
+      ROUTE_TYPE_HEADER
+    ]) {
+      if (response.headers.has(headerName)) {
+        response.headers.delete(headerName);
+      }
     }
     if (addCookieHeader) {
-      for (const setCookieHeaderValue of BaseApp.getSetCookieFromResponse(response)) {
+      for (const setCookieHeaderValue of getSetCookiesFromResponse(response)) {
         response.headers.append("set-cookie", setCookieHeaderValue);
       }
     }
     Reflect.set(response, responseSentSymbol, true);
-    return response;
   }
   setCookieHeaders(response) {
     return getSetCookiesFromResponse(response);
@@ -368,13 +414,11 @@ class BaseApp {
    * This also handles pre-rendered /404 or /500 routes
    */
   async renderError(request, {
-    locals,
     status,
     response: originalResponse,
     skipMiddleware = false,
     error,
-    clientAddress,
-    prerenderedErrorPageFetch
+    ...resolvedRenderOptions
   }) {
     const errorRoutePath = `/${status}${this.manifest.trailingSlash === "always" ? "/" : ""}`;
     const errorRouteData = matchRoute(errorRoutePath, this.manifestData);
@@ -383,17 +427,21 @@ class BaseApp {
       if (errorRouteData.prerender) {
         const maybeDotHtml = errorRouteData.route.endsWith(`/${status}`) ? ".html" : "";
         const statusURL = new URL(`${this.baseWithoutTrailingSlash}/${status}${maybeDotHtml}`, url);
-        if (statusURL.toString() !== request.url && prerenderedErrorPageFetch) {
-          const response2 = await prerenderedErrorPageFetch(statusURL.toString());
+        if (statusURL.toString() !== request.url && resolvedRenderOptions.prerenderedErrorPageFetch) {
+          const response2 = await resolvedRenderOptions.prerenderedErrorPageFetch(
+            statusURL.toString()
+          );
           const override = { status, removeContentEncodingHeaders: true };
-          return this.mergeResponses(response2, originalResponse, override);
+          const newResponse = this.mergeResponses(response2, originalResponse, override);
+          this.#prepareResponse(newResponse, resolvedRenderOptions);
+          return newResponse;
         }
       }
       const mod = await this.pipeline.getComponentByRoute(errorRouteData);
       let session;
       try {
         const renderContext = await this.createRenderContext({
-          locals,
+          locals: resolvedRenderOptions.locals,
           pipeline: this.pipeline,
           skipMiddleware,
           pathname: this.getPathnameFromRequest(request),
@@ -401,20 +449,20 @@ class BaseApp {
           routeData: errorRouteData,
           status,
           props: { error },
-          clientAddress
+          clientAddress: resolvedRenderOptions.clientAddress
         });
         session = renderContext.session;
         const response2 = await renderContext.render(mod);
-        return this.mergeResponses(response2, originalResponse);
+        const newResponse = this.mergeResponses(response2, originalResponse);
+        this.#prepareResponse(newResponse, resolvedRenderOptions);
+        return newResponse;
       } catch {
         if (skipMiddleware === false) {
           return this.renderError(request, {
-            locals,
+            ...resolvedRenderOptions,
             status,
             response: originalResponse,
-            skipMiddleware: true,
-            clientAddress,
-            prerenderedErrorPageFetch
+            skipMiddleware: true
           });
         }
       } finally {
@@ -422,7 +470,7 @@ class BaseApp {
       }
     }
     const response = this.mergeResponses(new Response(null, { status }), originalResponse);
-    Reflect.set(response, responseSentSymbol, true);
+    this.#prepareResponse(response, resolvedRenderOptions);
     return response;
   }
   mergeResponses(newResponse, originalResponse, override) {
@@ -447,15 +495,18 @@ class BaseApp {
       originalResponse.headers.delete("Content-type");
     } catch {
     }
-    const mergedHeaders = new Map([
-      ...Array.from(newResponseHeaders),
-      ...Array.from(originalResponse.headers)
-    ]);
     const newHeaders = new Headers();
-    for (const [name, value] of mergedHeaders) {
-      newHeaders.set(name, value);
+    const seen = /* @__PURE__ */ new Set();
+    for (const [name, value] of originalResponse.headers) {
+      newHeaders.append(name, value);
+      seen.add(name.toLowerCase());
     }
-    return new Response(newResponse.body, {
+    for (const [name, value] of newResponseHeaders) {
+      if (!seen.has(name.toLowerCase())) {
+        newHeaders.append(name, value);
+      }
+    }
+    const mergedResponse = new Response(newResponse.body, {
       status,
       statusText: status === 200 ? newResponse.statusText : originalResponse.statusText,
       // If you're looking at here for possible bugs, it means that it's not a bug.
@@ -465,6 +516,19 @@ class BaseApp {
       // Although, we don't want it to replace the content-type, because the error page must return `text/html`
       headers: newHeaders
     });
+    const originalCookies = getCookiesFromResponse(originalResponse);
+    const newCookies = getCookiesFromResponse(newResponse);
+    if (originalCookies) {
+      if (newCookies) {
+        for (const cookieValue of AstroCookies.consume(newCookies)) {
+          originalResponse.headers.append("set-cookie", cookieValue);
+        }
+      }
+      attachCookiesToResponse(mergedResponse, originalCookies);
+    } else if (newCookies) {
+      attachCookiesToResponse(mergedResponse, newCookies);
+    }
+    return mergedResponse;
   }
   getDefaultStatusCode(routeData, pathname) {
     if (!routeData.pattern.test(pathname)) {

package/dist/core/app/dev/app.d.ts

@@ -19,6 +19,6 @@ export declare class DevApp extends BaseApp<NonRunnablePipeline> {
     match(request: Request): RouteData | undefined;
     devMatch(pathname: string): Promise<DevMatch | undefined>;
     createRenderContext(payload: CreateRenderContext): Promise<RenderContext>;
-    renderError(request: Request, { locals, skipMiddleware, error, clientAddress, status }: RenderErrorOptions): Promise<Response>;
+    renderError(request: Request, { skipMiddleware, error, status, response: _response, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;
     logRequest({ pathname, method, statusCode, isRewrite, reqTime }: LogRequestPayload): void;
 }

package/dist/core/app/dev/app.js

@@ -56,7 +56,13 @@ class DevApp extends BaseApp {
       pathname: this.resolvedPathname ?? payload.pathname
     });
   }
-  async renderError(request, { locals, skipMiddleware = false, error, clientAddress, status }) {
+  async renderError(request, {
+    skipMiddleware = false,
+    error,
+    status,
+    response: _response,
+    ...resolvedRenderOptions
+  }) {
     if (isAstroError(error) && [MiddlewareNoDataOrNextCalled.name, MiddlewareNotAResponse.name].includes(error.name)) {
       throw error;
     }
@@ -64,13 +70,13 @@ class DevApp extends BaseApp {
       try {
         const preloadedComponent = await this.pipeline.getComponentByRoute(routeData);
         const renderContext = await this.createRenderContext({
-          locals,
+          locals: resolvedRenderOptions.locals,
           pipeline: this.pipeline,
-          pathname: await this.getPathnameFromRequest(request),
+          pathname: this.getPathnameFromRequest(request),
           skipMiddleware,
           request,
           routeData,
-          clientAddress,
+          clientAddress: resolvedRenderOptions.clientAddress,
           status,
           shouldInjectCspMetaTags: false
         });
@@ -83,8 +89,7 @@ class DevApp extends BaseApp {
       } catch (_err) {
         if (skipMiddleware === false) {
           return this.renderError(request, {
-            clientAddress: void 0,
-            prerenderedErrorPageFetch: fetch,
+            ...resolvedRenderOptions,
             status: 500,
             skipMiddleware: true,
             error: _err

package/dist/core/app/node.js

@@ -82,7 +82,8 @@ function createRequest(req, {
       onSocketClose();
     }
   }
-  const forwardedClientIp = getFirstForwardedValue(req.headers["x-forwarded-for"]);
+  const hostValidated = validated.host !== void 0 || validatedHostname !== void 0;
+  const forwardedClientIp = hostValidated ? getFirstForwardedValue(req.headers["x-forwarded-for"]) : void 0;
   const clientIp = forwardedClientIp || req.socket?.remoteAddress;
   if (clientIp) {
     Reflect.set(request, clientAddressSymbol, clientIp);

package/dist/core/app/types.d.ts

@@ -7,6 +7,7 @@ import type { SinglePageBuiltModule } from '../build/types.js';
 import type { CspDirective } from '../csp/config.js';
 import type { LoggerLevel } from '../logger/core.js';
 import type { RoutingStrategies } from './common.js';
+import type { CacheProviderFactory, SSRManifestCache } from '../cache/types.js';
 import type { BaseSessionConfig, SessionDriverFactory } from '../session/types.js';
 import type { DevToolbarPlacement } from '../../types/public/toolbar.js';
 import type { MiddlewareMode } from '../../types/public/integrations.js';
@@ -99,10 +100,14 @@ export type SSRManifest = {
     sessionDriver?: () => Promise<{
         default: SessionDriverFactory | null;
     }>;
+    cacheProvider?: () => Promise<{
+        default: CacheProviderFactory | null;
+    }>;
     checkOrigin: boolean;
     allowedDomains?: Partial<RemotePattern>[];
     actionBodySizeLimit: number;
     sessionConfig?: SSRManifestSession;
+    cacheConfig?: SSRManifestCache;
     cacheDir: URL;
     srcDir: URL;
     outDir: URL;