astro 4.1.3 → 4.2.1

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

@@ -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;
@@ -2170,6 +2270,7 @@ export interface RoutePart {
 type RedirectConfig = string | {
     status: ValidRedirectStatus;
     destination: string;
+    priority?: RoutePriorityOverride;
 };
 export interface RouteData {
     route: string;

package/dist/cli/preferences/index.js

@@ -5,10 +5,7 @@ import { resolveConfig } from "../../core/config/config.js";
 import { createSettings } from "../../core/config/settings.js";
 import * as msg from "../../core/messages.js";
 import { DEFAULT_PREFERENCES } from "../../preferences/defaults.js";
-import {
-  coerce,
-  isValidKey
-} from "../../preferences/index.js";
+import { coerce, isValidKey } from "../../preferences/index.js";
 import { createLoggerFromFlags, flagsToAstroInlineConfig } from "../flags.js";
 import { flattie } from "flattie";
 import { formatWithOptions } from "node:util";

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

package/dist/core/app/index.js

@@ -19,9 +19,10 @@ import {
 import { matchRoute } from "../routing/match.js";
 import { EndpointNotFoundError, SSRRoutePipeline } from "./ssrPipeline.js";
 import { deserializeManifest } from "./common.js";
-const clientLocalsSymbol = Symbol.for("astro.locals");
+const localsSymbol = Symbol.for("astro.locals");
+const clientAddressSymbol = Symbol.for("astro.clientAddress");
 const responseSentSymbol = Symbol.for("astro.responseSent");
-const STATUS_CODES = /* @__PURE__ */ new Set([404, 500]);
+const REROUTABLE_STATUS_CODES = /* @__PURE__ */ new Set([404, 500]);
 class App {
   /**
    * The current environment of the application
@@ -115,7 +116,15 @@ class App {
   async render(request, routeDataOrOptions, maybeLocals) {
     let routeData;
     let locals;
-    if (routeDataOrOptions && ("routeData" in routeDataOrOptions || "locals" in routeDataOrOptions)) {
+    let clientAddress;
+    let addCookieHeader;
+    if (routeDataOrOptions && ("addCookieHeader" in routeDataOrOptions || "clientAddress" in routeDataOrOptions || "locals" in routeDataOrOptions || "routeData" in routeDataOrOptions)) {
+      if ("addCookieHeader" in routeDataOrOptions) {
+        addCookieHeader = routeDataOrOptions.addCookieHeader;
+      }
+      if ("clientAddress" in routeDataOrOptions) {
+        clientAddress = routeDataOrOptions.clientAddress;
+      }
       if ("routeData" in routeDataOrOptions) {
         routeData = routeDataOrOptions.routeData;
       }
@@ -129,6 +138,12 @@ class App {
         this.#logRenderOptionsDeprecationWarning();
       }
     }
+    if (locals) {
+      Reflect.set(request, localsSymbol, locals);
+    }
+    if (clientAddress) {
+      Reflect.set(request, clientAddressSymbol, clientAddress);
+    }
     if (request.url !== collapseDuplicateSlashes(request.url)) {
       request = new Request(collapseDuplicateSlashes(request.url), request);
     }
@@ -138,7 +153,6 @@ class App {
     if (!routeData) {
       return this.#renderError(request, { status: 404 });
     }
-    Reflect.set(request, clientLocalsSymbol, locals ?? {});
     const pathname = this.#getPathnameFromRequest(request);
     const defaultStatus = this.#getDefaultStatusCode(routeData, pathname);
     const mod = await this.#getModuleForRoute(routeData);
@@ -153,7 +167,7 @@ class App {
     );
     let response;
     try {
-      let i18nMiddleware = createI18nMiddleware(
+      const i18nMiddleware = createI18nMiddleware(
         this.#manifest.i18n,
         this.#manifest.base,
         this.#manifest.trailingSlash
@@ -180,15 +194,19 @@ class App {
       }
     }
     if (routeData.type === "page" || routeData.type === "redirect") {
-      if (STATUS_CODES.has(response.status)) {
+      if (REROUTABLE_STATUS_CODES.has(response.status)) {
         return this.#renderError(request, {
           response,
           status: response.status
         });
       }
-      Reflect.set(response, responseSentSymbol, true);
-      return response;
     }
+    if (addCookieHeader) {
+      for (const setCookieHeaderValue of App.getSetCookieFromResponse(response)) {
+        response.headers.append("set-cookie", setCookieHeaderValue);
+      }
+    }
+    Reflect.set(response, responseSentSymbol, true);
     return response;
   }
   #logRenderOptionsDeprecationWarning() {
@@ -203,6 +221,18 @@ class App {
   setCookieHeaders(response) {
     return getSetCookiesFromResponse(response);
   }
+  /**
+   * 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 = getSetCookiesFromResponse;
   /**
    * Creates the render context of the current route
    */

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

@@ -1,25 +1,57 @@
 /// <reference types="node" resolution-mode="require"/>
+import { App } from './index.js';
+import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { RouteData } from '../../@types/astro.js';
 import type { RenderOptions } from './index.js';
 import type { SSRManifest } from './types.js';
-import { IncomingMessage } from 'node:http';
-import { App } from './index.js';
 export { apply as applyPolyfills } from '../polyfill.js';
-declare class NodeIncomingMessage extends IncomingMessage {
-    /**
-     * Allow the request body to be explicitly overridden. For example, this
-     * is used by the Express JSON middleware.
-     */
+/**
+ * Allow the request body to be explicitly overridden. For example, this
+ * is used by the Express JSON middleware.
+ */
+interface NodeRequest extends IncomingMessage {
     body?: unknown;
 }
 export declare class NodeApp extends App {
-    match(req: NodeIncomingMessage | Request): RouteData | undefined;
-    render(request: NodeIncomingMessage | Request, options?: RenderOptions): Promise<Response>;
+    match(req: NodeRequest | Request): RouteData | undefined;
+    render(request: NodeRequest | Request, options?: RenderOptions): Promise<Response>;
     /**
      * @deprecated Instead of passing `RouteData` and locals individually, pass an object with `routeData` and `locals` properties.
      * See https://github.com/withastro/astro/pull/9199 for more information.
      */
-    render(request: NodeIncomingMessage | Request, routeData?: RouteData, locals?: object): Promise<Response>;
+    render(request: NodeRequest | Request, routeData?: RouteData, locals?: object): Promise<Response>;
+    /**
+     * Converts a NodeJS IncomingMessage into a web standard Request.
+     * ```js
+     * import { NodeApp } from 'astro/app/node';
+     * import { createServer } from 'node:http';
+     *
+     * const server = createServer(async (req, res) => {
+     *     const request = NodeApp.createRequest(req);
+     *     const response = await app.render(request);
+     *     await NodeApp.writeResponse(response, res);
+     * })
+     * ```
+     */
+    static createRequest(req: NodeRequest, { skipBody }?: {
+        skipBody?: boolean | undefined;
+    }): Request;
+    /**
+     * Streams a web-standard Response into a NodeJS Server Response.
+     * ```js
+     * import { NodeApp } from 'astro/app/node';
+     * import { createServer } from 'node:http';
+     *
+     * const server = createServer(async (req, res) => {
+     *     const request = NodeApp.createRequest(req);
+     *     const response = await app.render(request);
+     *     await NodeApp.writeResponse(response, res);
+     * })
+     * ```
+     * @param source WhatWG Response
+     * @param destination NodeJS ServerResponse
+     */
+    static writeResponse(source: Response, destination: ServerResponse): Promise<void>;
 }
 export declare function loadManifest(rootFolder: URL): Promise<SSRManifest>;
 export declare function loadApp(rootFolder: URL): Promise<NodeApp>;

package/dist/core/app/node.js

@@ -1,30 +1,95 @@
-import * as fs from "node:fs";
-import { IncomingMessage } from "node:http";
-import { TLSSocket } from "node:tls";
-import { deserializeManifest } from "./common.js";
+import fs from "node:fs";
 import { App } from "./index.js";
+import { deserializeManifest } from "./common.js";
+import { createOutgoingHttpHeaders } from "./createOutgoingHttpHeaders.js";
 import { apply } from "../polyfill.js";
 const clientAddressSymbol = Symbol.for("astro.clientAddress");
-function createRequestFromNodeRequest(req, options) {
-  const protocol = req.socket instanceof TLSSocket || req.headers["x-forwarded-proto"] === "https" ? "https" : "http";
-  const hostname = req.headers.host || req.headers[":authority"];
-  const url = `${protocol}://${hostname}${req.url}`;
-  const headers = makeRequestHeaders(req);
-  const method = req.method || "GET";
-  let bodyProps = {};
-  const bodyAllowed = method !== "HEAD" && method !== "GET" && !options?.emptyBody;
-  if (bodyAllowed) {
-    bodyProps = makeRequestBody(req);
+class NodeApp extends App {
+  match(req) {
+    if (!(req instanceof Request)) {
+      req = NodeApp.createRequest(req, {
+        skipBody: true
+      });
+    }
+    return super.match(req);
+  }
+  render(req, routeDataOrOptions, maybeLocals) {
+    if (!(req instanceof Request)) {
+      req = NodeApp.createRequest(req);
+    }
+    return super.render(req, routeDataOrOptions, maybeLocals);
   }
-  const request = new Request(url, {
-    method,
-    headers,
-    ...bodyProps
-  });
-  if (req.socket?.remoteAddress) {
-    Reflect.set(request, clientAddressSymbol, req.socket.remoteAddress);
+  /**
+   * Converts a NodeJS IncomingMessage into a web standard Request.
+   * ```js
+   * import { NodeApp } from 'astro/app/node';
+   * import { createServer } from 'node:http';
+   *
+   * const server = createServer(async (req, res) => {
+   *     const request = NodeApp.createRequest(req);
+   *     const response = await app.render(request);
+   *     await NodeApp.writeResponse(response, res);
+   * })
+   * ```
+   */
+  static createRequest(req, { skipBody = false } = {}) {
+    const protocol = req.headers["x-forwarded-proto"] ?? ("encrypted" in req.socket && req.socket.encrypted ? "https" : "http");
+    const hostname = req.headers.host || req.headers[":authority"];
+    const url = `${protocol}://${hostname}${req.url}`;
+    const options = {
+      method: req.method || "GET",
+      headers: makeRequestHeaders(req)
+    };
+    const bodyAllowed = options.method !== "HEAD" && options.method !== "GET" && skipBody === false;
+    if (bodyAllowed) {
+      Object.assign(options, makeRequestBody(req));
+    }
+    const request = new Request(url, options);
+    if (req.socket?.remoteAddress) {
+      Reflect.set(request, clientAddressSymbol, req.socket.remoteAddress);
+    }
+    return request;
+  }
+  /**
+   * Streams a web-standard Response into a NodeJS Server Response.
+   * ```js
+   * import { NodeApp } from 'astro/app/node';
+   * import { createServer } from 'node:http';
+   *
+   * const server = createServer(async (req, res) => {
+   *     const request = NodeApp.createRequest(req);
+   *     const response = await app.render(request);
+   *     await NodeApp.writeResponse(response, res);
+   * })
+   * ```
+   * @param source WhatWG Response
+   * @param destination NodeJS ServerResponse
+   */
+  static async writeResponse(source, destination) {
+    const { status, headers, body } = source;
+    destination.writeHead(status, createOutgoingHttpHeaders(headers));
+    if (body) {
+      try {
+        const reader = body.getReader();
+        destination.on("close", () => {
+          reader.cancel().catch((err) => {
+            console.error(
+              `There was an uncaught error in the middle of the stream while rendering ${destination.req.url}.`,
+              err
+            );
+          });
+        });
+        let result = await reader.read();
+        while (!result.done) {
+          destination.write(result.value);
+          result = await reader.read();
+        }
+      } catch {
+        destination.write("Internal server error");
+      }
+    }
+    destination.end();
   }
-  return request;
 }
 function makeRequestHeaders(req) {
   const headers = new Headers();
@@ -65,33 +130,9 @@ function asyncIterableToBodyProps(iterable) {
     // The duplex property is required when using a ReadableStream or async
     // iterable for the body. The type definitions do not include the duplex
     // property because they are not up-to-date.
-    // @ts-expect-error
     duplex: "half"
   };
 }
-class NodeIncomingMessage extends IncomingMessage {
-  /**
-   * Allow the request body to be explicitly overridden. For example, this
-   * is used by the Express JSON middleware.
-   */
-  body;
-}
-class NodeApp extends App {
-  match(req) {
-    if (!(req instanceof Request)) {
-      req = createRequestFromNodeRequest(req, {
-        emptyBody: true
-      });
-    }
-    return super.match(req);
-  }
-  render(req, routeDataOrOptions, maybeLocals) {
-    if (!(req instanceof Request)) {
-      req = createRequestFromNodeRequest(req);
-    }
-    return super.render(req, routeDataOrOptions, maybeLocals);
-  }
-}
 async function loadManifest(rootFolder) {
   const manifestFile = new URL("./manifest.json", rootFolder);
   const rawManifest = await fs.promises.readFile(manifestFile, "utf-8");

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

@@ -1,5 +1,6 @@
 import type { Locales, RouteData, SerializedRouteData, SSRComponentMetadata, SSRLoadedRenderer, SSRResult } from '../../@types/astro.js';
 import type { SinglePageBuiltModule } from '../build/types.js';
+import type { RoutingStrategies } from '../config/schema.js';
 export type ComponentPath = string;
 export type StylesheetAsset = {
     type: 'inline';
@@ -47,7 +48,7 @@ export type SSRManifest = {
 };
 export type SSRManifestI18n = {
     fallback?: Record<string, string>;
-    routing?: 'prefix-always' | 'prefix-other-locales';
+    routing?: RoutingStrategies;
     locales: Locales;
     defaultLocale: string;
 };

package/dist/core/build/generate.js

@@ -344,9 +344,8 @@ function getUrlForPath(pathname, base, origin, format, routeType) {
   return url;
 }
 async function generatePath(pathname, pipeline, gopts, route) {
-  const { mod, scripts: hoistedScripts, styles: _styles, pageData } = gopts;
+  const { mod, scripts: hoistedScripts, styles: _styles } = gopts;
   const manifest = pipeline.getManifest();
-  const logger = pipeline.getLogger();
   pipeline.getEnvironment().logger.debug("build", `Generating: ${pathname}`);
   const links = /* @__PURE__ */ new Set();
   const scripts = createModuleScriptsSet(