@opennextjs/aws 4.1.14 → 4.1.16

package/dist/core/routing/routeParamPlaceholder.js

@@ -0,0 +1,42 @@
+import { dynamicRouteMatcher } from "./routeMatcher";
+// The placeholders of a route pattern: `[slug]`, `[...slug]` or `[[...slug]]`
+const PLACEHOLDER_REGEX = /\[\[\.\.\.[^\]]+\]\]|\[(?:\.\.\.)?[^\]]+\]/g;
+// A placeholder starts with `[`, which is either literal or percent encoded in the pathname
+const OPENING_BRACKET_REGEX = /\[|%5b/i;
+/**
+ * Returns whether a segment of the pathname is the placeholder of a matched dynamic App Router page.
+ *
+ * Next.js versions before 16.4.5 treat a param whose value is its placeholder (e.g. `[slug]` for `[slug]`) as an
+ * unresolved fallback param. Such values are not legitimate and must not reach Next.js.
+ *
+ * Segments are decoded like Next.js decodes param values (catch-all values are split on `/` first).
+ * Segments with a malformed percent encoding never match.
+ * Pathnames without an opening bracket return early, without matching the dynamic routes.
+ *
+ * @param pathname The internal pathname, which may include the basePath, a locale prefix and a trailing slash
+ * @returns Whether a segment of the pathname is a placeholder of a matched dynamic App Router page
+ */
+export function hasRouteParamPlaceholder(pathname) {
+    if (!OPENING_BRACKET_REGEX.test(pathname)) {
+        return false;
+    }
+    const placeholders = new Set(dynamicRouteMatcher(pathname)
+        .filter(({ type }) => type === "app")
+        .flatMap(({ route }) => route.match(PLACEHOLDER_REGEX) ?? []));
+    return (placeholders.size > 0 &&
+        pathname.split("/").some((segment) => placeholders.has(safeDecode(segment))));
+}
+/**
+ * Decodes a URI component without throwing.
+ *
+ * @param value The encoded value
+ * @returns The decoded value, or an empty string when the encoding is malformed
+ */
+function safeDecode(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return "";
+    }
+}

package/dist/core/routing/util.js

@@ -303,12 +303,20 @@ export async function revalidateIfRequired(host, rawPath, headers, req) {
         // If data has the same etag during these 5 min dedup window, it will be deduplicated and not revalidated.
         try {
             const hash = (str) => crypto.createHash("md5").update(str).digest("hex");
-            const lastModified = globalThis.__openNextAls.getStore()?.lastModified ?? 0;
+            const store = globalThis.__openNextAls.getStore();
+            // `1` when the entry is stale by tag, so that the deduplication id is the same for every copy of the entry
+            const lastModified = store?.lastModified ?? 0;
             // For some weird cases, lastModified is not set, haven't been able to figure out yet why
             // For those cases we add the etag to the deduplication id, it might help
             const eTag = `${headers.etag ?? headers.ETag ?? ""}`;
             await globalThis.queue.send({
-                MessageBody: { host, url: revalidateUrl, eTag, lastModified },
+                MessageBody: {
+                    host,
+                    url: revalidateUrl,
+                    eTag,
+                    // The time of the entry, so that the queue can skip it when it was revalidated since
+                    lastModified: store?.entryLastModified ?? lastModified,
+                },
                 MessageDeduplicationId: hash(`${rawPath}-${lastModified}-${eTag}`),
                 MessageGroupId: generateMessageGroupId(rawPath),
             });

package/dist/core/routingHandler.d.ts

@@ -3,6 +3,8 @@ import type { AssetResolver } from "../types/overrides.js";
 export declare const MIDDLEWARE_HEADER_PREFIX = "x-middleware-response-";
 export declare const MIDDLEWARE_HEADER_PREFIX_LEN: number;
 export declare const INTERNAL_HEADER_PREFIX = "x-opennext-";
+export declare const NEXT_CONFIG_HEADER_PREFIX = "x-opennext-next-config-response-";
+export declare const NEXT_CONFIG_HEADER_PREFIX_LEN: number;
 export declare const INTERNAL_HEADER_INITIAL_URL = "x-opennext-initial-url";
 export declare const INTERNAL_HEADER_LOCALE = "x-opennext-locale";
 export declare const INTERNAL_HEADER_RESOLVED_ROUTES = "x-opennext-resolved-routes";

package/dist/core/routingHandler.js

@@ -6,10 +6,13 @@ import { detectLocale } from "./routing/i18n";
 import { fixDataPage, getNextConfigHeaders, handleBeforeFilesRewrites, handleFallbackFalse, handleRedirects, handleRewrites, } from "./routing/matcher";
 import { handleMiddleware } from "./routing/middleware";
 import { dynamicRouteMatcher, staticRouteMatcher, } from "./routing/routeMatcher";
+import { hasRouteParamPlaceholder } from "./routing/routeParamPlaceholder";
 import { constructNextUrl, normalizeLocationHeader } from "./routing/util";
 export const MIDDLEWARE_HEADER_PREFIX = "x-middleware-response-";
 export const MIDDLEWARE_HEADER_PREFIX_LEN = MIDDLEWARE_HEADER_PREFIX.length;
 export const INTERNAL_HEADER_PREFIX = "x-opennext-";
+export const NEXT_CONFIG_HEADER_PREFIX = `${INTERNAL_HEADER_PREFIX}next-config-response-`;
+export const NEXT_CONFIG_HEADER_PREFIX_LEN = NEXT_CONFIG_HEADER_PREFIX.length;
 export const INTERNAL_HEADER_INITIAL_URL = `${INTERNAL_HEADER_PREFIX}initial-url`;
 export const INTERNAL_HEADER_LOCALE = `${INTERNAL_HEADER_PREFIX}locale`;
 export const INTERNAL_HEADER_RESOLVED_ROUTES = `${INTERNAL_HEADER_PREFIX}resolved-routes`;
@@ -39,24 +42,34 @@ const NEXT_INTERNAL_HEADERS = [
     "x-matched-path",
     "x-nextjs-data",
     "x-next-resume-state-length",
+    "next-resume",
 ];
 /**
- * Adds the middleware headers to an event or result.
+ * Adds the `next.config` and middleware response headers to an event or result.
  *
- * @param eventOrResult
- * @param middlewareHeaders
+ * On an event, each kind gets its own prefix so that the request handler can tell them apart (see
+ * `splitRoutingHeaders`). On a result, the headers are the response and are not prefixed.
+ *
+ * `nextConfigHeaders` take precedence over `middlewareHeaders` on the response.
+ *
+ * @param eventOrResult The event or result to add the headers to, its headers are mutated
+ * @param nextConfigHeaders The response headers from the `next.config` `headers()`
+ * @param middlewareHeaders The response headers set by the middleware
  */
-function applyMiddlewareHeaders(eventOrResult, middlewareHeaders) {
-    // Use the `MIDDLEWARE_HEADER_PREFIX` prefix for events, they will be processed by the request handler later.
-    // Results do not go through the request handler and should not be prefixed.
+function applyResponseHeaders(eventOrResult, nextConfigHeaders, middlewareHeaders) {
     const isResult = isInternalResult(eventOrResult);
     const headers = eventOrResult.headers;
-    const keyPrefix = isResult ? "" : MIDDLEWARE_HEADER_PREFIX;
-    Object.entries(middlewareHeaders).forEach(([key, value]) => {
-        if (value) {
-            headers[keyPrefix + key] = Array.isArray(value) ? value.join(",") : value;
+    const addHeaders = (source, keyPrefix) => {
+        for (const [key, value] of Object.entries(source)) {
+            if (value) {
+                headers[keyPrefix + key] = Array.isArray(value)
+                    ? value.join(",")
+                    : value;
+            }
         }
-    });
+    };
+    addHeaders(middlewareHeaders, isResult ? "" : MIDDLEWARE_HEADER_PREFIX);
+    addHeaders(nextConfigHeaders, isResult ? "" : NEXT_CONFIG_HEADER_PREFIX);
 }
 export default async function routingHandler(event, { assetResolver }) {
     try {
@@ -77,8 +90,7 @@ export default async function routingHandler(event, { assetResolver }) {
                 delete event.headers[key];
             }
         }
-        // Headers from the Next config and middleware (the later are applied further down).
-        let headers = getNextConfigHeaders(event, ConfigHeaders);
+        let nextConfigHeaders = getNextConfigHeaders(event, ConfigHeaders);
         let eventOrResult = fixDataPage(event, BuildId);
         if (isInternalResult(eventOrResult)) {
             return eventOrResult;
@@ -100,17 +112,10 @@ export default async function routingHandler(event, { assetResolver }) {
         }
         const middlewareHeadersPrioritized = globalThis.openNextConfig.dangerous
             ?.middlewareHeadersOverrideNextConfigHeaders ?? false;
+        const middlewareHeaders = middlewareEventOrResult.responseHeaders ?? {};
         if (middlewareHeadersPrioritized) {
-            headers = {
-                ...headers,
-                ...middlewareEventOrResult.responseHeaders,
-            };
-        }
-        else {
-            headers = {
-                ...middlewareEventOrResult.responseHeaders,
-                ...headers,
-            };
+            // Both are keyed by lowercase name.
+            nextConfigHeaders = Object.fromEntries(Object.entries(nextConfigHeaders).filter(([key]) => !Object.hasOwn(middlewareHeaders, key)));
         }
         let isExternalRewrite = middlewareEventOrResult.isExternalRewrite ?? false;
         eventOrResult = middlewareEventOrResult;
@@ -126,7 +131,7 @@ export default async function routingHandler(event, { assetResolver }) {
             if (!isExternalRewrite) {
                 const assetResult = await assetResolver?.maybeGetAssetResult?.(eventOrResult);
                 if (assetResult) {
-                    applyMiddlewareHeaders(assetResult, headers);
+                    applyResponseHeaders(assetResult, nextConfigHeaders, middlewareHeaders);
                     return assetResult;
                 }
             }
@@ -159,7 +164,7 @@ export default async function routingHandler(event, { assetResolver }) {
         const isRouteFoundBeforeAllRewrites = isStaticRoute || isDynamicRoute || isExternalRewrite;
         // Resolve against the final internal pathname after every rewrite phase.
         // These ordered matches are also the authoritative cache owner candidates.
-        const resolvedRoutes = [
+        let resolvedRoutes = [
             ...staticRouteMatcher(eventOrResult.rawPath),
             ...dynamicRouteMatcher(eventOrResult.rawPath),
         ];
@@ -169,7 +174,12 @@ export default async function routingHandler(event, { assetResolver }) {
             isNextImageRoute ||
             // We need to check again once all rewrites have been applied
             staticRouteMatcher(eventOrResult.rawPath).length > 0 ||
-            dynamicRouteMatcher(eventOrResult.rawPath).length > 0)) {
+            dynamicRouteMatcher(eventOrResult.rawPath).length > 0) ||
+            // Next.js versions before 16.4.5 treat a param whose value is its placeholder (e.g. `[slug]`) as unresolved.
+            // Next.js receives both the rawPath and the URL pathname, which is normalized (e.g. dot segments).
+            (!isExternalRewrite &&
+                [eventOrResult.rawPath, new URL(eventOrResult.url).pathname].some(hasRouteParamPlaceholder))) {
+            resolvedRoutes = [];
             eventOrResult = {
                 ...eventOrResult,
                 rawPath: "/404",
@@ -186,12 +196,12 @@ export default async function routingHandler(event, { assetResolver }) {
             debug("Cache interception enabled");
             eventOrResult = await cacheInterceptor(eventOrResult, resolvedRoutes);
             if (isInternalResult(eventOrResult)) {
-                applyMiddlewareHeaders(eventOrResult, headers);
+                applyResponseHeaders(eventOrResult, nextConfigHeaders, middlewareHeaders);
                 return eventOrResult;
             }
         }
-        // We apply the headers from the middleware response last
-        applyMiddlewareHeaders(eventOrResult, headers);
+        // We apply the response headers last
+        applyResponseHeaders(eventOrResult, nextConfigHeaders, middlewareHeaders);
         debug("resolvedRoutes", resolvedRoutes);
         return {
             internalEvent: eventOrResult,

package/dist/http/framing.d.ts

@@ -0,0 +1,35 @@
+import type { ServerResponse } from "node:http";
+import { type Writable } from "node:stream";
+/**
+ * Largest `content-length` that is verified by buffering the body.
+ *
+ * It matches the largest response compressed by CloudFront, which only compresses responses with a `content-length`.
+ * Larger responses are streamed without `content-length`.
+ */
+export declare const MAX_VERIFIED_CONTENT_LENGTH = 10000000;
+/**
+ * Writes the head of a Node.js `ServerResponse` and returns the stream to write the body to.
+ *
+ * The framing headers set by the app may not match the body that is actually written (e.g. a `fetch()` response
+ * body is decoded but keeps the upstream `content-length`). The bytes past a stale `content-length` would stay on
+ * the keep-alive connection and be read as the next response.
+ *
+ * - `transfer-encoding` is always removed, Node.js picks the transfer coding.
+ * - A `content-length` that is not a valid length is removed.
+ * - `content-length` is kept for HEAD requests and 304 responses, Node.js does not write a body for them.
+ * - Otherwise `content-length` is only kept when the body has exactly the declared length. The body is buffered
+ *   until this is known, and the head is written then, so the first byte is only sent once the whole body is
+ *   received. When the length doesn't match, or is larger than `MAX_VERIFIED_CONTENT_LENGTH`, `content-length` is
+ *   removed and Node.js frames the body itself (chunked on HTTP/1.1).
+ *
+ * The status code and the headers are always validated synchronously, even when the head is written later.
+ *
+ * @param res The Node.js response.
+ * @param method The request method.
+ * @param statusCode The response status code.
+ * @param headers The response headers, keys are matched case-insensitively.
+ * @returns The stream to write the body to.
+ * @throws When the status code or a header is invalid, or the headers were already sent (same errors as
+ *   `res.writeHead()`).
+ */
+export declare function writeResponseHead(res: ServerResponse, method: string | undefined, statusCode: number, headers: Record<string, string>): Writable;

package/dist/http/framing.js

@@ -0,0 +1,181 @@
+import { Transform } from "node:stream";
+import { error } from "../adapters/logger";
+/**
+ * Largest `content-length` that is verified by buffering the body.
+ *
+ * It matches the largest response compressed by CloudFront, which only compresses responses with a `content-length`.
+ * Larger responses are streamed without `content-length`.
+ */
+export const MAX_VERIFIED_CONTENT_LENGTH = 10_000_000;
+/**
+ * Writes the head of a Node.js `ServerResponse` and returns the stream to write the body to.
+ *
+ * The framing headers set by the app may not match the body that is actually written (e.g. a `fetch()` response
+ * body is decoded but keeps the upstream `content-length`). The bytes past a stale `content-length` would stay on
+ * the keep-alive connection and be read as the next response.
+ *
+ * - `transfer-encoding` is always removed, Node.js picks the transfer coding.
+ * - A `content-length` that is not a valid length is removed.
+ * - `content-length` is kept for HEAD requests and 304 responses, Node.js does not write a body for them.
+ * - Otherwise `content-length` is only kept when the body has exactly the declared length. The body is buffered
+ *   until this is known, and the head is written then, so the first byte is only sent once the whole body is
+ *   received. When the length doesn't match, or is larger than `MAX_VERIFIED_CONTENT_LENGTH`, `content-length` is
+ *   removed and Node.js frames the body itself (chunked on HTTP/1.1).
+ *
+ * The status code and the headers are always validated synchronously, even when the head is written later.
+ *
+ * @param res The Node.js response.
+ * @param method The request method.
+ * @param statusCode The response status code.
+ * @param headers The response headers, keys are matched case-insensitively.
+ * @returns The stream to write the body to.
+ * @throws When the status code or a header is invalid, or the headers were already sent (same errors as
+ *   `res.writeHead()`).
+ */
+export function writeResponseHead(res, method, statusCode, headers) {
+    validateHead(res, statusCode);
+    let contentLength;
+    for (const [key, value] of Object.entries(headers)) {
+        const lowerKey = key.toLowerCase();
+        if (lowerKey === "content-length") {
+            contentLength = value;
+        }
+        else if (lowerKey !== "transfer-encoding") {
+            // `setHeader()` validates the header like `writeHead()` does
+            res.setHeader(key, value);
+        }
+    }
+    const expectedLength = parseContentLength(contentLength);
+    if (!Number.isNaN(expectedLength) &&
+        (method?.toUpperCase() === "HEAD" || statusCode === 304)) {
+        res.setHeader("content-length", String(expectedLength));
+        res.writeHead(statusCode);
+        res.flushHeaders();
+        return res;
+    }
+    if (statusCode === 204 || !(expectedLength <= MAX_VERIFIED_CONTENT_LENGTH)) {
+        res.writeHead(statusCode);
+        res.flushHeaders();
+        return res;
+    }
+    const body = new ContentLengthVerifier(res, statusCode, expectedLength);
+    body.pipe(res);
+    return body;
+}
+/**
+ * Checks that the head can be written, the way `res.writeHead()` does.
+ *
+ * The headers are validated by `res.setHeader()`.
+ *
+ * @param res The Node.js response.
+ * @param statusCode The response status code.
+ * @throws {Error} When the headers were already sent (code `ERR_HTTP_HEADERS_SENT`).
+ * @throws {RangeError} When the status code is not in 100-999 (code `ERR_HTTP_INVALID_STATUS_CODE`).
+ */
+function validateHead(res, statusCode) {
+    if (res.headersSent) {
+        throw Object.assign(new Error("Cannot write headers after they are sent to the client"), { code: "ERR_HTTP_HEADERS_SENT" });
+    }
+    const code = statusCode | 0;
+    if (code < 100 || code > 999) {
+        throw Object.assign(new RangeError(`Invalid status code: ${statusCode}`), {
+            code: "ERR_HTTP_INVALID_STATUS_CODE",
+        });
+    }
+}
+/**
+ * Parses a `content-length` header value.
+ *
+ * @param contentLength The header value.
+ * @returns The length, or `NaN` when the value is missing or not a valid length.
+ */
+function parseContentLength(contentLength) {
+    const value = contentLength?.trim() ?? "";
+    const length = /^\d+$/.test(value) ? Number(value) : Number.NaN;
+    return Number.isSafeInteger(length) ? length : Number.NaN;
+}
+/**
+ * Buffers the body until it is known whether it has the declared length, then writes the head and the body.
+ *
+ * The headers, other than `content-length`, are already set on the response.
+ */
+class ContentLengthVerifier extends Transform {
+    res;
+    statusCode;
+    expectedLength;
+    chunks = [];
+    length = 0;
+    headWritten = false;
+    /**
+     * @param res The Node.js response.
+     * @param statusCode The response status code, already validated.
+     * @param expectedLength The declared `content-length`.
+     */
+    constructor(res, statusCode, expectedLength) {
+        super();
+        this.res = res;
+        this.statusCode = statusCode;
+        this.expectedLength = expectedLength;
+    }
+    /**
+     * Buffers the chunk until the head is written, then passes it through.
+     *
+     * The head is written without `content-length` as soon as the body is longer than declared.
+     *
+     * @param chunk The body chunk.
+     * @param _encoding Unused, chunks are buffers.
+     * @param callback Called once the chunk is processed.
+     */
+    _transform(chunk, _encoding, callback) {
+        if (this.headWritten) {
+            callback(null, chunk);
+            return;
+        }
+        this.chunks.push(chunk);
+        this.length += chunk.length;
+        if (this.length > this.expectedLength) {
+            this.writeHead(false);
+        }
+        callback();
+    }
+    /**
+     * Writes the head, when not already written, once the whole body is received.
+     *
+     * @param callback Called once the head and the buffered chunks are written.
+     */
+    _flush(callback) {
+        if (!this.headWritten) {
+            this.writeHead(this.length === this.expectedLength);
+        }
+        callback();
+    }
+    /**
+     * Writes the head and the buffered chunks.
+     *
+     * This runs from the stream callbacks, where a thrown error would be uncaught and crash the process. The
+     * head is validated synchronously in `writeResponseHead()`, if writing it still fails, the response is destroyed.
+     *
+     * @param keepContentLength Whether the body has the declared length.
+     */
+    writeHead(keepContentLength) {
+        this.headWritten = true;
+        const chunks = this.chunks;
+        this.chunks = [];
+        try {
+            if (keepContentLength) {
+                this.res.setHeader("content-length", String(this.expectedLength));
+            }
+            this.res.writeHead(this.statusCode);
+        }
+        catch (e) {
+            error("Failed to write the response head", e);
+            this.res.destroy();
+            // Without an error, no `error` event is emitted
+            this.destroy();
+            return;
+        }
+        for (const chunk of chunks) {
+            this.push(chunk);
+        }
+    }
+}

package/dist/http/util.d.ts

@@ -8,6 +8,17 @@ export declare const convertHeader: (header: http.OutgoingHttpHeader) => string;
  * @returns A list of Set-Cookie header
  */
 export declare function parseSetCookieHeader(cookies: string | string[] | null | undefined): string[];
+/**
+ * Converts the headers of a response returned by an edge function.
+ *
+ * `Set-Cookie` headers are returned as a list.
+ * The internal `x-middleware-set-cookie` header is dropped: `NextResponse` sets it when
+ * `response.cookies` is modified (i.e. in a route handler) and it contains the `HttpOnly` cookies.
+ *
+ * @param headers The headers of the response
+ * @returns The response headers to send to the client
+ */
+export declare function convertEdgeResponseHeaders(headers: Pick<Headers, "forEach" | "getSetCookie">): Record<string, string | string[]>;
 /**
  *
  * Get the query object from an iterable of [key, value] pairs

package/dist/http/util.js

@@ -58,6 +58,32 @@ export function parseSetCookieHeader(cookies) {
     }
     return cookies;
 }
+/**
+ * Converts the headers of a response returned by an edge function.
+ *
+ * `Set-Cookie` headers are returned as a list.
+ * The internal `x-middleware-set-cookie` header is dropped: `NextResponse` sets it when
+ * `response.cookies` is modified (i.e. in a route handler) and it contains the `HttpOnly` cookies.
+ *
+ * @param headers The headers of the response
+ * @returns The response headers to send to the client
+ */
+export function convertEdgeResponseHeaders(headers) {
+    const responseHeaders = {};
+    headers.forEach((value, key) => {
+        const lowerKey = key.toLowerCase();
+        // Headers.forEach folds same-name headers; use getSetCookie() below instead.
+        if (lowerKey === "set-cookie" || lowerKey === "x-middleware-set-cookie") {
+            return;
+        }
+        responseHeaders[key] = value;
+    });
+    const setCookies = headers.getSetCookie();
+    if (setCookies.length > 0) {
+        responseHeaders["set-cookie"] = setCookies;
+    }
+    return responseHeaders;
+}
 /**
  *
  * Get the query object from an iterable of [key, value] pairs

package/dist/minimize-js.d.ts

@@ -1 +1,10 @@
+/**
+ * Minifies the JS (and optionally JSON) files of a directory in place.
+ *
+ * Calls can run concurrently. Failed files are logged and do not throw.
+ *
+ * @param dir Directory to walk recursively.
+ * @param opts Minification options.
+ * @return A promise that resolves once all the files have been processed.
+ */
 export declare function minifyAll(dir: any, opts: any): Promise<void>;

package/dist/minimize-js.js

@@ -4,11 +4,8 @@
 // @ts-nocheck
 import fs from "node:fs/promises";
 import path from "node:path";
-import minify from "@node-minify/core";
-import terser from "@node-minify/terser";
-const failed_files = [];
-let total_files = 0;
-const options = {};
+import { minify } from "@node-minify/core";
+import { terser } from "@node-minify/terser";
 const promiseSeries = async (tasks, initial) => {
     if (!Array.isArray(tasks)) {
         return Promise.reject(new TypeError("promise.series only accepts an array of functions"));
@@ -17,29 +14,28 @@ const promiseSeries = async (tasks, initial) => {
         return current.then(next);
     }, Promise.resolve(initial));
 };
-const minifyJS = async (file) => {
-    total_files++;
+const minifyJS = async (file, ctx) => {
     try {
         await minify({
             compressor: terser,
             input: file,
             output: file,
+            // node-minify 10 throws when the output is empty (i.e. empty or comment-only files)
+            allowEmptyOutput: true,
             options: {
-                module: options.module,
-                mangle: options.mangle,
+                module: ctx.options.module,
+                mangle: ctx.options.mangle,
                 compress: { reduce_vars: false },
             },
         });
     }
     catch (e) {
-        failed_files.push(file);
+        ctx.failed_files.push(file);
     }
-    //process.stdout.write(".");
 };
-const minifyJSON = async (file) => {
+const minifyJSON = async (file, options) => {
     try {
         if (options.compress_json || options.packagejson) {
-            total_files++;
             const is_package_json = file.indexOf("package.json") > -1;
             const data = await fs.readFile(file, "utf8");
             const json = JSON.parse(data);
@@ -63,9 +59,8 @@ const minifyJSON = async (file) => {
         }
     }
     catch (e) { }
-    //process.stdout.write(".");
 };
-const walk = async (currentDirPath) => {
+const walk = async (currentDirPath, ctx) => {
     const js_files = [];
     const json_files = [];
     const dirs = [];
@@ -77,26 +72,32 @@ const walk = async (currentDirPath) => {
         if (stat.isFile()) {
             if (filePath.substr(-5) === ".json")
                 json_files.push(filePath);
-            else if (filePath.substr(-3) === ".js" || options.all_js)
+            else if (filePath.substr(-3) === ".js" || ctx.options.all_js)
                 js_files.push(filePath);
         }
         else if (stat.isDirectory() && !is_bin.test(filePath)) {
             dirs.push(filePath);
         }
     }
-    const js_promise = Promise.all(js_files.map((f) => minifyJS(f)));
-    const json_promise = Promise.all(json_files.map((f) => minifyJSON(f)));
+    const js_promise = Promise.all(js_files.map((f) => minifyJS(f, ctx)));
+    const json_promise = Promise.all(json_files.map((f) => minifyJSON(f, ctx.options)));
     await Promise.all([js_promise, json_promise]);
-    await promiseSeries(dirs.map((dir) => () => walk(dir)));
+    await promiseSeries(dirs.map((dir) => () => walk(dir, ctx)));
 };
+/**
+ * Minifies the JS (and optionally JSON) files of a directory in place.
+ *
+ * Calls can run concurrently. Failed files are logged and do not throw.
+ *
+ * @param dir Directory to walk recursively.
+ * @param opts Minification options.
+ * @return A promise that resolves once all the files have been processed.
+ */
 export async function minifyAll(dir, opts) {
-    Object.assign(options, opts || {});
-    //console.log("minify-all-js options:\n", JSON.stringify(options, null, 2));
-    await walk(dir);
-    //process.stdout.write(".\n");
-    //console.log("Total found files: " + total_files);
-    if (failed_files.length) {
+    const ctx = { options: { ...opts }, failed_files: [] };
+    await walk(dir, ctx);
+    if (ctx.failed_files.length) {
         console.log("\n\nFailed to minify files:");
-        failed_files.forEach((f) => console.log(`\t${f}`));
+        ctx.failed_files.forEach((f) => console.log(`\t${f}`));
     }
 }

package/dist/overrides/proxyExternalRequest/fetch.js

@@ -4,7 +4,11 @@ const fetchProxy = {
     // @ts-ignore
     proxy: async (internalEvent) => {
         const { url, headers: eventHeaders, method, body } = internalEvent;
-        const headers = Object.fromEntries(Object.entries(eventHeaders).filter(([key]) => key.toLowerCase() !== "cf-connecting-ip"));
+        const headers = Object.fromEntries(Object.entries(eventHeaders).filter(([key]) => !["cf-connecting-ip", "x-forwarded-host"].includes(key.toLowerCase())));
+        // Like Next.js, do not relay the `x-forwarded-host` sent by the client
+        if (eventHeaders.host) {
+            headers["x-forwarded-host"] = eventHeaders.host;
+        }
         const response = await fetch(url, {
             method,
             headers,

package/dist/overrides/proxyExternalRequest/node.js

@@ -6,6 +6,7 @@ function filterHeadersForProxy(headers) {
     const filteredHeaders = {};
     const disallowedHeaders = [
         "host",
+        "x-forwarded-host",
         "connection",
         "via",
         "x-cache",
@@ -30,6 +31,10 @@ const nodeProxy = {
         debug("proxyRequest", url);
         return new Promise((resolve, reject) => {
             const filteredHeaders = filterHeadersForProxy(headers);
+            // Like Next.js, do not relay the `x-forwarded-host` sent by the client
+            if (headers.host) {
+                filteredHeaders["x-forwarded-host"] = headers.host;
+            }
             debug("filteredHeaders", filteredHeaders);
             const req = request(url, {
                 headers: filteredHeaders,

package/dist/overrides/wrappers/express-dev.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import express from "express";
 import { NextConfig } from "../../adapters/config/index.js";
+import { writeResponseHead } from "../../http/framing.js";
 import { getMonorepoRelativePath } from "../../utils/normalize-path.js";
 const wrapper = async (handler, converter) => {
     const app = express();
@@ -16,8 +17,7 @@ const wrapper = async (handler, converter) => {
         const internalEvent = await converter.convertFrom(req);
         const streamCreator = {
             writeHeaders: (prelude) => {
-                res.writeHead(prelude.statusCode, prelude.headers);
-                return res;
+                return writeResponseHead(res, req.method, prelude.statusCode, prelude.headers);
             },
         };
         await imageHandler(internalEvent, { streamCreator });
@@ -34,9 +34,7 @@ const wrapper = async (handler, converter) => {
         const streamCreator = {
             writeHeaders: (prelude) => {
                 res.setHeader("Set-Cookie", prelude.cookies);
-                res.writeHead(prelude.statusCode, prelude.headers);
-                res.flushHeaders();
-                return res;
+                return writeResponseHead(res, req.method, prelude.statusCode, prelude.headers);
             },
             onFinish: () => { },
             abortSignal: abortController.signal,