astro 4.1.2 → 4.2.0

package/components/ViewTransitions.astro

@@ -53,6 +53,9 @@ const { fallback = 'animate' } = Astro.props;
 	if (supportsViewTransitions || getFallback() !== 'none') {
 		document.addEventListener('click', (ev) => {
 			let link = ev.target;
+			if (ev.composed) {
+				link = ev.composedPath()[0];
+			}
 			if (link instanceof Element) {
 				link = link.closest('a, area');
 			}
@@ -106,7 +109,9 @@ const { fallback = 'animate' } = Astro.props;
 
 			// the "dialog" method is a special keyword used within <dialog> elements
 			// https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fs-method
-			if (method === 'dialog') {
+			if (method === 'dialog' || location.origin !== new URL(action, location.href).origin) {
+				// No page transitions in these cases,
+				// Let the browser standard action handle this
 				return;
 			}
 

package/dist/@types/astro.d.ts

@@ -15,9 +15,9 @@ import type { TSConfig } from '../core/config/tsconfig.js';
 import type { AstroCookies } from '../core/cookies/index.js';
 import type { AstroIntegrationLogger, Logger, LoggerLevel } from '../core/logger/core.js';
 import type { AstroPreferences } from '../preferences/index.js';
-import type { AstroDevOverlay, DevOverlayCanvas } from '../runtime/client/dev-overlay/overlay.js';
-import type { Icon } from '../runtime/client/dev-overlay/ui-library/icons.js';
-import type { DevOverlayBadge, DevOverlayButton, DevOverlayCard, DevOverlayHighlight, DevOverlayIcon, DevOverlayToggle, DevOverlayTooltip, DevOverlayWindow } from '../runtime/client/dev-overlay/ui-library/index.js';
+import type { AstroDevToolbar, DevToolbarCanvas } from '../runtime/client/dev-toolbar/toolbar.js';
+import type { Icon } from '../runtime/client/dev-toolbar/ui-library/icons.js';
+import type { DevToolbarBadge, DevToolbarButton, DevToolbarCard, DevToolbarHighlight, DevToolbarIcon, DevToolbarToggle, DevToolbarTooltip, DevToolbarWindow } from '../runtime/client/dev-toolbar/ui-library/index.js';
 import type { AstroComponentFactory, AstroComponentInstance } from '../runtime/server/index.js';
 import type { DeepPartial, OmitIndexSignature, Simplify } from '../type-utils.js';
 import type { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from './../core/constants.js';
@@ -1374,6 +1374,34 @@ export interface AstroUserConfig {
              * Localized folders are used for every language, including the default.
              */
             prefixDefaultLocale: boolean;
+            /**
+             * @docs
+             * @name i18n.routing.redirectToDefaultLocale
+             * @kind h4
+             * @type {boolean}
+             * @default `true`
+             * @version 4.2.0
+             * @description
+             *
+             * Configures whether or not the home URL (`/`) generated by `src/pages/index.astro`
+             * will redirect to `/[defaultLocale]` when `prefixDefaultLocale: true` is set.
+             *
+             * Set `redirectToDefaultLocale: false` to disable this automatic redirection at the root of your site:
+             * ```js
+             * // astro.config.mjs
+             * export default defineConfig({
+             *   i18n:{
+             *     defaultLocale: "en",
+             * 		locales: ["en", "fr"],
+             *     routing: {
+             *       prefixDefaultLocale: true,
+             *       redirectToDefaultLocale: false
+             *     }
+             *   }
+             * })
+             *```
+             * */
+            redirectToDefaultLocale: boolean;
             /**
              * @name i18n.routing.strategy
              * @type {"pathname"}
@@ -1444,6 +1472,70 @@ export interface AstroUserConfig {
          * ```
          */
         contentCollectionCache?: boolean;
+        /**
+         * @docs
+         * @name experimental.clientPrerender
+         * @type {boolean}
+         * @default `false`
+         * @version 4.2.0
+         * @description
+         * Enables pre-rendering your prefetched pages on the client in supported browsers.
+         *
+         * This feature uses the experimental [Speculation Rules Web API](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API) and overrides the default `prefetch` behavior globally to prerender links on the client.
+         * You may wish to review the [possible risks when prerendering on the client](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API#unsafe_prefetching) before enabling this feature.
+         *
+         * Enable client side prerendering in your `astro.config.mjs` along with any desired `prefetch` configuration options:
+         *
+         * ```js
+         * // astro.config.mjs
+         * {
+         *   prefetch: {
+         *     prefetchAll: true,
+         *     defaultStrategy: 'viewport',
+         *   },
+         * 	experimental: {
+         * 		clientPrerender: true,
+         * 	},
+         * }
+         * ```
+         *
+         * Continue to use the `data-astro-prefetch` attribute on any `<a />` link on your site to opt in to prefetching.
+         * Instead of appending a `<link>` tag to the head of the document or fetching the page with JavaScript, a `<script>` tag will be appended with the corresponding speculation rules.
+         *
+         * Client side prerendering requires browser support. If the Speculation Rules API is not supported, `prefetch` will fallback to the supported strategy.
+         *
+         * See the [Prefetch Guide](https://docs.astro.build/en/guides/prefetch/) for more `prefetch` options and usage.
+         */
+        clientPrerender?: boolean;
+        /**
+         * @docs
+         * @name experimental.globalRoutePriority
+         * @type {boolean}
+         * @default `false`
+         * @version 4.2.0
+         * @description
+         *
+         * Prioritizes redirects and injected routes equally alongside file-based project routes, following the same [route priority order rules](https://docs.astro.build/en/core-concepts/routing/#route-priority-order) for all routes.
+         *
+         * This allows more control over routing in your project by not automatically prioritizing certain types of routes, and standardizes the route priority ordering for all routes.
+         *
+         * The following example shows which route will build certain page URLs when file-based routes, injected routes, and redirects are combined as shown below:
+         * - File-based route: `/blog/post/[pid]`
+         * - File-based route: `/[page]`
+         * - Injected route: `/blog/[...slug]`
+         * - Redirect: `/blog/tags/[tag]` -> `/[tag]`
+         * - Redirect: `/posts` -> `/blog`
+         *
+         * With `experimental.globalRoutingPriority` enabled (instead of Astro 4.0 default route priority order):
+         *
+         * - `/blog/tags/astro` is built by the redirect to `/tags/[tag]` (instead of the injected route `/blog/[...slug]`)
+         * - `/blog/post/0` is built by the file-based route `/blog/post/[pid]` (instead of the injected route `/blog/[...slug]`)
+         * - `/posts` is built by the redirect to `/blog` (instead of the file-based route `/[page]`)
+         *
+         *
+         * In the event of route collisions, where two routes of equal route priority attempt to build the same URL, Astro will log a warning identifying the conflicting routes.
+         */
+        globalRoutePriority?: boolean;
     };
 }
 /**
@@ -1454,6 +1546,14 @@ export interface AstroUserConfig {
  * - "page-ssr": Injected into the frontmatter of every Astro page. Processed & resolved by Vite.
  */
 export type InjectedScriptStage = 'before-hydration' | 'head-inline' | 'page' | 'page-ssr';
+/**
+ * IDs for different priorities of injected routes and redirects:
+ * - "normal": Merge with discovered file-based project routes, behaving the same as if the route
+ *   was defined as a file in the project.
+ * - "legacy": Use the old ordering of routes. Inject routes will override any file-based project route,
+ *   and redirects will be overridden by any project route on conflict.
+ */
+export type RoutePriorityOverride = 'normal' | 'legacy';
 export interface InjectedRoute {
     pattern: string;
     entrypoint: string;
@@ -2082,6 +2182,7 @@ export interface AstroIntegration {
             addClientDirective: (directive: ClientDirectiveConfig) => void;
             /**
              * @deprecated Use `addDevToolbarApp` instead.
+             * TODO: Fully remove in Astro 5.0
              */
             addDevOverlayPlugin: (entrypoint: string) => void;
             addDevToolbarApp: (entrypoint: string) => void;
@@ -2169,6 +2270,7 @@ export interface RoutePart {
 type RedirectConfig = string | {
     status: ValidRedirectStatus;
     destination: string;
+    priority?: RoutePriorityOverride;
 };
 export interface RouteData {
     route: string;
@@ -2302,8 +2404,8 @@ export interface DevToolbarApp {
     beforeTogglingOff?(canvas: ShadowRoot): boolean | Promise<boolean>;
 }
 export type DevOverlayPlugin = DevToolbarApp;
-export type DevOverlayMetadata = Window & typeof globalThis & {
-    __astro_dev_overlay__: {
+export type DevToolbarMetadata = Window & typeof globalThis & {
+    __astro_dev_toolbar__: {
         root: string;
         version: string;
         debugInfo: string;
@@ -2311,25 +2413,25 @@ export type DevOverlayMetadata = Window & typeof globalThis & {
 };
 declare global {
     interface HTMLElementTagNameMap {
-        'astro-dev-toolbar': AstroDevOverlay;
-        'astro-dev-toolbar-window': DevOverlayWindow;
-        'astro-dev-toolbar-plugin-canvas': DevOverlayCanvas;
-        'astro-dev-toolbar-tooltip': DevOverlayTooltip;
-        'astro-dev-toolbar-highlight': DevOverlayHighlight;
-        'astro-dev-toolbar-toggle': DevOverlayToggle;
-        'astro-dev-toolbar-badge': DevOverlayBadge;
-        'astro-dev-toolbar-button': DevOverlayButton;
-        'astro-dev-toolbar-icon': DevOverlayIcon;
-        'astro-dev-toolbar-card': DevOverlayCard;
-        'astro-dev-overlay': AstroDevOverlay;
-        'astro-dev-overlay-window': DevOverlayWindow;
-        'astro-dev-overlay-plugin-canvas': DevOverlayCanvas;
-        'astro-dev-overlay-tooltip': DevOverlayTooltip;
-        'astro-dev-overlay-highlight': DevOverlayHighlight;
-        'astro-dev-overlay-toggle': DevOverlayToggle;
-        'astro-dev-overlay-badge': DevOverlayBadge;
-        'astro-dev-overlay-button': DevOverlayButton;
-        'astro-dev-overlay-icon': DevOverlayIcon;
-        'astro-dev-overlay-card': DevOverlayCard;
+        'astro-dev-toolbar': AstroDevToolbar;
+        'astro-dev-toolbar-window': DevToolbarWindow;
+        'astro-dev-toolbar-app-canvas': DevToolbarCanvas;
+        'astro-dev-toolbar-tooltip': DevToolbarTooltip;
+        'astro-dev-toolbar-highlight': DevToolbarHighlight;
+        'astro-dev-toolbar-toggle': DevToolbarToggle;
+        'astro-dev-toolbar-badge': DevToolbarBadge;
+        'astro-dev-toolbar-button': DevToolbarButton;
+        'astro-dev-toolbar-icon': DevToolbarIcon;
+        'astro-dev-toolbar-card': DevToolbarCard;
+        'astro-dev-overlay': AstroDevToolbar;
+        'astro-dev-overlay-window': DevToolbarWindow;
+        'astro-dev-overlay-plugin-canvas': DevToolbarCanvas;
+        'astro-dev-overlay-tooltip': DevToolbarTooltip;
+        'astro-dev-overlay-highlight': DevToolbarHighlight;
+        'astro-dev-overlay-toggle': DevToolbarToggle;
+        'astro-dev-overlay-badge': DevToolbarBadge;
+        'astro-dev-overlay-button': DevToolbarButton;
+        'astro-dev-overlay-icon': DevToolbarIcon;
+        'astro-dev-overlay-card': DevToolbarCard;
     }
 }

package/dist/assets/internal.js

@@ -41,6 +41,7 @@ async function getImage(options, imageConfig) {
     ...options,
     src: typeof options.src === "object" && "then" in options.src ? (await options.src).default ?? await options.src : options.src
   };
+  const originalPath = isESMImportedImage(resolvedOptions.src) ? resolvedOptions.src.fsPath : resolvedOptions.src;
   const clonedSrc = isESMImportedImage(resolvedOptions.src) ? (
     // @ts-expect-error - clone is a private, hidden prop
     resolvedOptions.src.clone ?? resolvedOptions.src
@@ -59,10 +60,10 @@ async function getImage(options, imageConfig) {
   );
   if (isLocalService(service) && globalThis.astroAsset.addStaticImage && !(isRemoteImage(validatedOptions.src) && imageURL === validatedOptions.src)) {
     const propsToHash = service.propertiesToHash ?? DEFAULT_HASH_PROPS;
-    imageURL = globalThis.astroAsset.addStaticImage(validatedOptions, propsToHash);
+    imageURL = globalThis.astroAsset.addStaticImage(validatedOptions, propsToHash, originalPath);
     srcSets = srcSetTransforms.map((srcSet) => ({
       transform: srcSet.transform,
-      url: globalThis.astroAsset.addStaticImage(srcSet.transform, propsToHash),
+      url: globalThis.astroAsset.addStaticImage(srcSet.transform, propsToHash, originalPath),
       descriptor: srcSet.descriptor,
       attributes: srcSet.attributes
     }));

package/dist/assets/services/noop.js

@@ -1,10 +1,7 @@
 import { baseService } from "./service.js";
 const noopService = {
+  ...baseService,
   propertiesToHash: ["src"],
-  validateOptions: baseService.validateOptions,
-  getURL: baseService.getURL,
-  parseURL: baseService.parseURL,
-  getHTMLAttributes: baseService.getHTMLAttributes,
   async transform(inputBuffer, transformOptions) {
     return {
       data: inputBuffer,

package/dist/assets/types.d.ts

@@ -15,7 +15,7 @@ export type AssetsGlobalStaticImagesList = Map<string, {
 declare global {
     var astroAsset: {
         imageService?: ImageService;
-        addStaticImage?: ((options: ImageTransform, hashProperties: string[]) => string) | undefined;
+        addStaticImage?: ((options: ImageTransform, hashProperties: string[], fsPath: string) => string) | undefined;
         staticImages?: AssetsGlobalStaticImagesList;
         referencedImages?: Set<string>;
     };

package/dist/assets/utils/emitAsset.js

@@ -22,7 +22,7 @@ async function emitESMImage(id, watchMode, fileEmitter) {
   Object.defineProperty(emittedImage, "fsPath", {
     enumerable: false,
     writable: false,
-    value: url
+    value: id
   });
   if (!watchMode) {
     const pathname = decodeURI(url.pathname);

package/dist/assets/utils/proxy.d.ts

@@ -1 +1,2 @@
-export declare function getProxyCode(options: Record<string, any>, isSSR: boolean): string;
+import type { ImageMetadata } from '../types.js';
+export declare function getProxyCode(options: ImageMetadata, isSSR: boolean): string;

package/dist/assets/utils/proxy.js

@@ -1,11 +1,15 @@
 function getProxyCode(options, isSSR) {
+  const stringifiedFSPath = JSON.stringify(options.fsPath);
   return `
 						new Proxy(${JSON.stringify(options)}, {
 						get(target, name, receiver) {
 							if (name === 'clone') {
 								return structuredClone(target);
 							}
-							${!isSSR ? "globalThis.astroAsset.referencedImages.add(target.fsPath);" : ""}
+							if (name === 'fsPath') {
+								return ${stringifiedFSPath};
+							}
+							${!isSSR ? `globalThis.astroAsset.referencedImages.add(${stringifiedFSPath});` : ""}
 							return target[name];
 						}
 					})

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

@@ -15,7 +15,8 @@ import { isESMImportedImage } from "./utils/imageKind.js";
 import { getProxyCode } from "./utils/proxy.js";
 import { hashTransform, propsToFilename } from "./utils/transformToPath.js";
 const resolvedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
-const assetRegex = new RegExp(`\\.(${VALID_INPUT_FORMATS.join("|")})$`, "i");
+const assetRegex = new RegExp(`\\.(${VALID_INPUT_FORMATS.join("|")})`, "i");
+const assetRegexEnds = new RegExp(`\\.(${VALID_INPUT_FORMATS.join("|")})$`, "i");
 function assets({
   settings,
   mode
@@ -67,12 +68,11 @@ function assets({
         if (mode != "build") {
           return;
         }
-        globalThis.astroAsset.addStaticImage = (options, hashProperties) => {
+        globalThis.astroAsset.addStaticImage = (options, hashProperties, originalPath) => {
           if (!globalThis.astroAsset.staticImages) {
             globalThis.astroAsset.staticImages = /* @__PURE__ */ new Map();
           }
           const finalOriginalImagePath = (isESMImportedImage(options.src) ? options.src.src : options.src).replace(settings.config.build.assetsPrefix || "", "");
-          const originalSrcPath = isESMImportedImage(options.src) ? options.src.fsPath : options.src;
           const hash = hashTransform(
             options,
             settings.config.image.service.entrypoint,
@@ -89,7 +89,7 @@ function assets({
             );
             if (!transformsForPath) {
               globalThis.astroAsset.staticImages.set(finalOriginalImagePath, {
-                originalSrcPath,
+                originalSrcPath: originalPath,
                 transforms: /* @__PURE__ */ new Map()
               });
               transformsForPath = globalThis.astroAsset.staticImages.get(finalOriginalImagePath);
@@ -137,24 +137,31 @@ function assets({
         resolvedConfig = viteConfig;
       },
       async load(id, options) {
-        if (id !== removeQueryString(id)) {
-          return;
-        }
         if (assetRegex.test(id)) {
-          const meta = await emitESMImage(id, this.meta.watchMode, this.emitFile);
-          if (!meta) {
+          if (!globalThis.astroAsset.referencedImages)
+            globalThis.astroAsset.referencedImages = /* @__PURE__ */ new Set();
+          if (id !== removeQueryString(id)) {
+            globalThis.astroAsset.referencedImages.add(removeQueryString(id));
+            return;
+          }
+          if (!assetRegexEnds.test(id)) {
+            return;
+          }
+          const imageMetadata = await emitESMImage(id, this.meta.watchMode, this.emitFile);
+          if (!imageMetadata) {
             throw new AstroError({
               ...AstroErrorData.ImageNotFound,
               message: AstroErrorData.ImageNotFound.message(id)
             });
           }
           if (options?.ssr) {
-            return `export default ${getProxyCode(meta, isServerLikeOutput(settings.config))}`;
+            return `export default ${getProxyCode(
+              imageMetadata,
+              isServerLikeOutput(settings.config)
+            )}`;
           } else {
-            if (!globalThis.astroAsset.referencedImages)
-              globalThis.astroAsset.referencedImages = /* @__PURE__ */ new Set();
-            globalThis.astroAsset.referencedImages.add(meta.fsPath);
-            return `export default ${JSON.stringify(meta)}`;
+            globalThis.astroAsset.referencedImages.add(imageMetadata.fsPath);
+            return `export default ${JSON.stringify(imageMetadata)}`;
           }
         }
       }

package/dist/content/runtime-assets.d.ts

@@ -1,7 +1,7 @@
 import type { PluginContext } from 'rollup';
 import { z } from 'zod';
 export declare function createImage(pluginContext: PluginContext, entryFilePath: string): () => z.ZodEffects<z.ZodString, z.ZodNever | {
-    ASTRO_ASSET: boolean;
+    ASTRO_ASSET: string;
     src: string;
     width: number;
     height: number;

package/dist/content/runtime-assets.js

@@ -17,7 +17,7 @@ function createImage(pluginContext, entryFilePath) {
         });
         return z.never();
       }
-      return { ...metadata, ASTRO_ASSET: true };
+      return { ...metadata, ASTRO_ASSET: metadata.fsPath };
     });
   };
 }

package/dist/content/types-generator.js

@@ -18,8 +18,6 @@ import {
   getEntryType,
   reloadContentConfigObserver
 } from "./utils.js";
-class UnsupportedFileTypeError extends Error {
-}
 async function createContentTypesGenerator({
   contentConfigObserver,
   fs,
@@ -98,20 +96,6 @@ async function createContentTypesGenerator({
       await reloadContentConfigObserver({ fs, settings, viteServer });
       return { shouldGenerateTypes: true };
     }
-    if (fileType === "unsupported") {
-      if (event.name === "unlink") {
-        return { shouldGenerateTypes: false };
-      }
-      const { id: id2 } = getContentEntryIdAndSlug({
-        entry: event.entry,
-        contentDir: contentPaths.contentDir,
-        collection: ""
-      });
-      return {
-        shouldGenerateTypes: false,
-        error: new UnsupportedFileTypeError(id2)
-      };
-    }
     const { entry } = event;
     const { contentDir } = contentPaths;
     const collection = getEntryCollectionName({ entry, contentDir });
@@ -251,16 +235,6 @@ async function createContentTypesGenerator({
       eventResponses.push(response);
     }
     events = [];
-    for (const response of eventResponses) {
-      if (response.error instanceof UnsupportedFileTypeError) {
-        logger.warn(
-          "content",
-          `Unsupported file type ${bold(
-            response.error.message
-          )} found. Prefix filename with an underscore (\`_\`) to ignore.`
-        );
-      }
-    }
     const observable = contentConfigObserver.get();
     if (eventResponses.some((r) => r.shouldGenerateTypes)) {
       await writeContentFiles({

package/dist/content/utils.d.ts

@@ -117,7 +117,7 @@ export declare function getContentEntryIdAndSlug({ entry, contentDir, collection
     id: string;
     slug: string;
 };
-export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir'>, contentFileExts: string[], dataFileExts: string[]): 'content' | 'data' | 'config' | 'ignored' | 'unsupported';
+export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir'>, contentFileExts: string[], dataFileExts: string[]): 'content' | 'data' | 'config' | 'ignored';
 export declare function hasUnderscoreBelowContentDirectoryPath(fileUrl: URL, contentDir: ContentPaths['contentDir']): boolean;
 export declare function parseFrontmatter(fileContents: string): matter.GrayMatterFile<string>;
 /**

package/dist/content/utils.js

@@ -5,7 +5,6 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { normalizePath } from "vite";
 import { z } from "zod";
-import { VALID_INPUT_FORMATS } from "../assets/consts.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { formatYAMLException, isYAMLException } from "../core/errors/utils.js";
 import { CONTENT_FLAGS, CONTENT_TYPES_FILE } from "./consts.js";
@@ -163,9 +162,9 @@ function getRelativeEntryPath(entry, collection, contentDir) {
   return relativeToCollection;
 }
 function getEntryType(entryPath, paths, contentFileExts, dataFileExts) {
-  const { ext, base } = path.parse(entryPath);
+  const { ext } = path.parse(entryPath);
   const fileUrl = pathToFileURL(entryPath);
-  if (hasUnderscoreBelowContentDirectoryPath(fileUrl, paths.contentDir) || isOnIgnoreList(base) || isImageAsset(ext)) {
+  if (hasUnderscoreBelowContentDirectoryPath(fileUrl, paths.contentDir)) {
     return "ignored";
   } else if (contentFileExts.includes(ext)) {
     return "content";
@@ -174,15 +173,9 @@ function getEntryType(entryPath, paths, contentFileExts, dataFileExts) {
   } else if (fileUrl.href === paths.config.url.href) {
     return "config";
   } else {
-    return "unsupported";
+    return "ignored";
   }
 }
-function isOnIgnoreList(fileName) {
-  return [".DS_Store"].includes(fileName);
-}
-function isImageAsset(fileExt) {
-  return VALID_INPUT_FORMATS.includes(fileExt.slice(1));
-}
 function hasUnderscoreBelowContentDirectoryPath(fileUrl, contentDir) {
   const parts = fileUrl.pathname.replace(contentDir.pathname, "").split("/");
   for (const part of parts) {

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

@@ -268,6 +268,7 @@ function stringifyEntryData(data, isSSR) {
       }
       if (typeof value === "object" && "ASTRO_ASSET" in value) {
         const { ASTRO_ASSET, ...asset } = value;
+        asset.fsPath = ASTRO_ASSET;
         return getProxyCode(asset, isSSR);
       }
     });

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

@@ -0,0 +1,9 @@
+import type { OutgoingHttpHeaders } from 'node:http';
+/**
+ * Takes in a nullable WebAPI Headers object and produces a NodeJS OutgoingHttpHeaders object suitable for usage
+ * with ServerResponse.writeHead(..) or ServerResponse.setHeader(..)
+ *
+ * @param headers WebAPI Headers object
+ * @returns {OutgoingHttpHeaders} NodeJS OutgoingHttpHeaders object with multiple set-cookie handled as an array of values
+ */
+export declare const createOutgoingHttpHeaders: (headers: Headers | undefined | null) => OutgoingHttpHeaders | undefined;

package/dist/core/app/createOutgoingHttpHeaders.js

@@ -0,0 +1,19 @@
+const createOutgoingHttpHeaders = (headers) => {
+  if (!headers) {
+    return void 0;
+  }
+  const nodeHeaders = Object.fromEntries(headers.entries());
+  if (Object.keys(nodeHeaders).length === 0) {
+    return void 0;
+  }
+  if (headers.has("set-cookie")) {
+    const cookieHeaders = headers.getSetCookie();
+    if (cookieHeaders.length > 1) {
+      nodeHeaders["set-cookie"] = cookieHeaders;
+    }
+  }
+  return nodeHeaders;
+};
+export {
+  createOutgoingHttpHeaders
+};

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

@@ -1,9 +1,34 @@
 import type { ManifestData, RouteData, SSRManifest } from '../../@types/astro.js';
+import { getSetCookiesFromResponse } from '../cookies/index.js';
 import { AstroIntegrationLogger } from '../logger/core.js';
 export { deserializeManifest } from './common.js';
 export interface RenderOptions {
-    routeData?: RouteData;
+    /**
+     * Whether to automatically add all cookies written by `Astro.cookie.set()` to the response headers.
+     *
+     * When set to `true`, they will be added to the `Set-Cookie` header as comma-separated key=value pairs. You can use the standard `response.headers.getSetCookie()` API to read them individually.
+     *
+     * When set to `false`, the cookies will only be available from `App.getSetCookieFromResponse(response)`.
+     *
+     * @default {false}
+     */
+    addCookieHeader?: boolean;
+    /**
+     * The client IP address that will be made available as `Astro.clientAddress` in pages, and as `ctx.clientAddress` in API routes and middleware.
+     *
+     * Default: `request[Symbol.for("astro.clientAddress")]`
+     */
+    clientAddress?: string;
+    /**
+     * The mutable object that will be made available as `Astro.locals` in pages, and as `ctx.locals` in API routes and middleware.
+     */
     locals?: object;
+    /**
+     * **Advanced API**: you probably do not need to use this.
+     *
+     * Default: `app.match(request)`
+     */
+    routeData?: RouteData;
 }
 export interface RenderErrorOptions {
     routeData?: RouteData;
@@ -28,4 +53,16 @@ export declare class App {
      */
     render(request: Request, routeData?: RouteData, locals?: object): Promise<Response>;
     setCookieHeaders(response: Response): Generator<string, string[], unknown>;
+    /**
+     * Reads all the cookies written by `Astro.cookie.set()` onto the passed response.
+     * For example,
+     * ```ts
+     * for (const cookie_ of App.getSetCookieFromResponse(response)) {
+     *     const cookie: string = cookie_
+     * }
+     * ```
+     * @param response The response to read cookies from.
+     * @returns An iterator that yields key-value pairs as equal-sign-separated strings.
+     */
+    static getSetCookieFromResponse: typeof getSetCookiesFromResponse;
 }