@opennextjs/aws 3.1.6 → 3.2.1

package/dist/core/resolve.js

@@ -3,7 +3,7 @@ export async function resolveConverter(converter) {
         return converter();
     }
     else {
-        const m_1 = await import(`../converters/aws-apigw-v2.js`);
+        const m_1 = await import(`../overrides/converters/aws-apigw-v2.js`);
         // @ts-expect-error
         return m_1.default;
     }
@@ -14,7 +14,7 @@ export async function resolveWrapper(wrapper) {
     }
     else {
         // This will be replaced by the bundler
-        const m_1 = await import("../wrappers/aws-lambda.js");
+        const m_1 = await import("../overrides/wrappers/aws-lambda.js");
         // @ts-expect-error
         return m_1.default;
     }
@@ -31,7 +31,7 @@ export async function resolveTagCache(tagCache) {
     }
     else {
         // This will be replaced by the bundler
-        const m_1 = await import("../cache/tag/dynamodb.js");
+        const m_1 = await import("../overrides/tagCache/dynamodb.js");
         return m_1.default;
     }
 }
@@ -46,7 +46,7 @@ export async function resolveQueue(queue) {
         return queue();
     }
     else {
-        const m_1 = await import("../queue/sqs.js");
+        const m_1 = await import("../overrides/queue/sqs.js");
         return m_1.default;
     }
 }
@@ -61,7 +61,7 @@ export async function resolveIncrementalCache(incrementalCache) {
         return incrementalCache();
     }
     else {
-        const m_1 = await import("../cache/incremental/s3.js");
+        const m_1 = await import("../overrides/incrementalCache/s3.js");
         return m_1.default;
     }
 }
@@ -79,3 +79,28 @@ export async function resolveImageLoader(imageLoader) {
         return m_1.default;
     }
 }
+/**
+ * @returns
+ * @__PURE__
+ */
+export async function resolveOriginResolver(originResolver) {
+    if (typeof originResolver === "function") {
+        return originResolver();
+    }
+    else {
+        const m_1 = await import("../overrides/originResolver/pattern-env.js");
+        return m_1.default;
+    }
+}
+/**
+ * @__PURE__
+ */
+export async function resolveWarmerInvoke(warmer) {
+    if (typeof warmer === "function") {
+        return warmer();
+    }
+    else {
+        const m_1 = await import("../overrides/warmer/aws-lambda.js");
+        return m_1.default;
+    }
+}

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

@@ -1,2 +1,2 @@
-import { InternalEvent, InternalResult } from "../../types/open-next";
+import type { InternalEvent, InternalResult } from "../../types/open-next";
 export declare function cacheInterceptor(event: InternalEvent): Promise<InternalEvent | InternalResult>;

package/dist/core/routing/i18n/index.d.ts

@@ -1,2 +1,2 @@
-import { InternalEvent } from "../../../types/open-next";
+import type { InternalEvent } from "../../../types/open-next";
 export declare function localizePath(internalEvent: InternalEvent): string;

package/dist/core/routing/i18n/index.js

@@ -13,6 +13,9 @@ function getLocaleFromCookie(cookies) {
         : undefined;
 }
 function detectLocale(internalEvent, i18n) {
+    if (i18n.localeDetection === false) {
+        return i18n.defaultLocale;
+    }
     const cookiesLocale = getLocaleFromCookie(internalEvent.cookies);
     const preferredLocale = acceptLanguage(internalEvent.headers["accept-language"], i18n?.locales);
     debug({

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

@@ -1,6 +1,7 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import type { Header, PrerenderManifest, RedirectDefinition, RewriteDefinition } from "../../types/next-types";
-import { InternalEvent, InternalResult } from "../../types/open-next";
+import type { InternalEvent, InternalResult } from "../../types/open-next";
 export declare function addNextConfigHeaders(event: InternalEvent, configHeaders?: Header[] | undefined): Record<string, string | undefined>;
 export declare function handleRewrites<T extends RewriteDefinition>(event: InternalEvent, rewrites: T[]): {
     internalEvent: {

package/dist/core/routing/matcher.js

@@ -1,5 +1,5 @@
 import { NextConfig } from "../../adapters/config/index";
-import { compile, match, } from "path-to-regexp";
+import { compile, match } from "path-to-regexp";
 import { emptyReadableStream, toReadableStream } from "../../utils/stream";
 import { debug } from "../../adapters/logger";
 import { localizePath } from "./i18n";
@@ -122,10 +122,16 @@ export function handleRewrites(event, rewrites) {
         const { pathname, protocol, hostname, queryString } = getUrlParts(rewrite.destination, isExternalRewrite);
         // We need to use a localized path if the rewrite is not locale specific
         const pathToUse = rewrite.locale === false ? rawPath : localizedRawPath;
+        // We need to encode the "+" character with its UTF-8 equivalent "%20" to avoid 2 issues:
+        // 1. The compile function from path-to-regexp will throw an error if it finds a "+" character.
+        // https://github.com/pillarjs/path-to-regexp?tab=readme-ov-file#unexpected--or-
+        // 2. The convertToQueryString function will replace the "+" character with %2B instead of %20.
+        // %2B does not get interpreted as a space in the URL thus breaking the query string.
+        const encodePlusQueryString = queryString.replaceAll("+", "%20");
         debug("urlParts", { pathname, protocol, hostname, queryString });
         const toDestinationPath = compile(escapeRegex(pathname ?? "") ?? "");
         const toDestinationHost = compile(escapeRegex(hostname ?? "") ?? "");
-        const toDestinationQuery = compile(escapeRegex(queryString ?? "") ?? "");
+        const toDestinationQuery = compile(escapeRegex(encodePlusQueryString ?? "") ?? "");
         let params = {
             // params for the source
             ...getParamsFromSource(match(escapeRegex(rewrite?.source) ?? ""))(pathToUse),
@@ -139,7 +145,7 @@ export function handleRewrites(event, rewrites) {
             }, {}),
         };
         const isUsingParams = Object.keys(params).length > 0;
-        let rewrittenQuery = queryString;
+        let rewrittenQuery = encodePlusQueryString;
         let rewrittenHost = hostname;
         let rewrittenPath = pathname;
         if (isUsingParams) {
@@ -149,7 +155,7 @@ export function handleRewrites(event, rewrites) {
         }
         rewrittenUrl = isExternalRewrite
             ? `${protocol}//${rewrittenHost}${rewrittenPath}`
-            : `/${rewrittenPath}`;
+            : `${rewrittenPath}`;
         // Should we merge the query params or use only the ones from the rewrite?
         finalQuery = {
             ...query,
@@ -244,8 +250,9 @@ export function fixDataPage(internalEvent, buildId) {
         };
     }
     if (rawPath.startsWith(dataPattern) && rawPath.endsWith(".json")) {
-        let newPath = rawPath.replace(dataPattern, "").replace(/\.json$/, "");
-        newPath = newPath === "/index" ? "/" : newPath;
+        const newPath = rawPath
+            .slice(dataPattern.length, -".json".length)
+            .replace(/^\/index$/, "/");
         query.__nextDataReq = "1";
         return {
             ...internalEvent,

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

@@ -1,7 +1,11 @@
-import { InternalEvent, InternalResult } from "../../types/open-next.js";
+import type { InternalEvent, InternalResult } from "../../types/open-next.js";
 type MiddlewareOutputEvent = InternalEvent & {
     responseHeaders?: Record<string, string | string[]>;
     externalRewrite?: boolean;
 };
-export declare function handleMiddleware(internalEvent: InternalEvent): Promise<MiddlewareOutputEvent | InternalResult>;
+type Middleware = (request: Request) => Response | Promise<Response>;
+type MiddlewareLoader = () => Promise<{
+    default: Middleware;
+}>;
+export declare function handleMiddleware(internalEvent: InternalEvent, middlewareLoader?: MiddlewareLoader): Promise<MiddlewareOutputEvent | InternalResult>;
 export {};

package/dist/core/routing/middleware.js

@@ -11,12 +11,16 @@ import { localizePath } from "./i18n/index.js";
 import { convertBodyToReadableStream, convertToQueryString, getMiddlewareMatch, isExternal, } from "./util.js";
 const middlewareManifest = MiddlewareManifest;
 const middleMatch = getMiddlewareMatch(middlewareManifest);
+function defaultMiddlewareLoader() {
+    // @ts-expect-error - This is bundled
+    return import("./middleware.mjs");
+}
 // NOTE: As of Nextjs 13.4.13+, the middleware is handled outside the next-server.
 // OpenNext will run the middleware in a sandbox and set the appropriate req headers
 // and res.body prior to processing the next-server.
 // @returns undefined | res.end()
 //    if res.end() is return, the parent needs to return and not process next server
-export async function handleMiddleware(internalEvent) {
+export async function handleMiddleware(internalEvent, middlewareLoader = defaultMiddlewareLoader) {
     const { query } = internalEvent;
     const normalizedPath = localizePath(internalEvent);
     // We only need the normalizedPath to check if the middleware should run
@@ -26,15 +30,17 @@ export async function handleMiddleware(internalEvent) {
     // We bypass the middleware if the request is internal
     if (internalEvent.headers["x-isr"])
         return internalEvent;
+    // Retrieve the protocol:
+    // - In lambda, the url only contains the rawPath and the query - default to https
+    // - In cloudflare, the protocol is usually http in dev and https in production
+    const protocol = internalEvent.url.startsWith("http://") ? "http:" : "https:";
     const host = internalEvent.headers.host
-        ? `https://${internalEvent.headers.host}`
+        ? `${protocol}//${internalEvent.headers.host}`
         : "http://localhost:3000";
     const initialUrl = new URL(normalizedPath, host);
     initialUrl.search = convertToQueryString(query);
     const url = initialUrl.toString();
-    // console.log("url", url, normalizedPath);
-    // @ts-expect-error - This is bundled
-    const middleware = await import("./middleware.mjs");
+    const middleware = await middlewareLoader();
     const result = await middleware.default({
         geo: {
             city: internalEvent.headers["x-open-next-city"],
@@ -93,7 +99,7 @@ export async function handleMiddleware(internalEvent) {
         resHeaders.location =
             responseHeaders
                 .get("location")
-                ?.replace("http://localhost:3000", `https://${internalEvent.headers.host}`) ?? resHeaders.location;
+                ?.replace("http://localhost:3000", `${protocol}//${internalEvent.headers.host}`) ?? resHeaders.location;
         // res.setHeader("Location", location);
         return {
             body: emptyReadableStream(),
@@ -153,7 +159,7 @@ export async function handleMiddleware(internalEvent) {
         responseHeaders: resHeaders,
         url: newUrl,
         rawPath: rewritten
-            ? newUrl ?? internalEvent.rawPath
+            ? (newUrl ?? internalEvent.rawPath)
             : internalEvent.rawPath,
         type: internalEvent.type,
         headers: { ...internalEvent.headers, ...reqHeaders },

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

@@ -1,10 +1,11 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { OutgoingHttpHeaders } from "node:http";
+/// <reference types="node" />
+import type { OutgoingHttpHeaders } from "node:http";
 import type { IncomingMessage, StreamCreator } from "../../http/index.js";
 import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
 import type { MiddlewareManifest } from "../../types/next-types";
-import { InternalEvent, InternalResult } from "../../types/open-next.js";
+import type { InternalEvent, InternalResult } from "../../types/open-next.js";
 /**
  *
  * @__PURE__

package/dist/core/routing/util.js

@@ -1,6 +1,6 @@
 import crypto from "node:crypto";
 import { Readable } from "node:stream";
-import { BuildId, HtmlPages } from "../../adapters/config/index.js";
+import { BuildId, HtmlPages, NextConfig } from "../../adapters/config/index.js";
 import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
 import { parseHeaders } from "../../http/util.js";
 import { isBinaryContentType } from "../../adapters/binary.js";
@@ -37,7 +37,7 @@ export function getUrlParts(url, isExternal) {
         const match = url.match(regex);
         return {
             hostname: "",
-            pathname: match?.[1] ?? url,
+            pathname: match?.[1] ? `/${match[1]}` : url,
             protocol: "",
             queryString: match?.[2] ?? "",
         };
@@ -50,7 +50,7 @@ export function getUrlParts(url, isExternal) {
     return {
         protocol: match[1] ?? "https:",
         hostname: match[2],
-        pathname: match[3],
+        pathname: match[3] ?? "",
         queryString: match[4]?.slice(1) ?? "",
     };
 }
@@ -84,13 +84,16 @@ export function convertRes(res) {
  * @__PURE__
  */
 export function convertToQueryString(query) {
+    // URLSearchParams is a representation of the PARSED query.
+    // So we must decode the value before appending it to the URLSearchParams.
+    // https://stackoverflow.com/a/45516812
     const urlQuery = new URLSearchParams();
     Object.entries(query).forEach(([key, value]) => {
         if (Array.isArray(value)) {
-            value.forEach((entry) => urlQuery.append(key, entry));
+            value.forEach((entry) => urlQuery.append(key, decodeURIComponent(entry)));
         }
         else {
-            urlQuery.append(key, value);
+            urlQuery.append(key, decodeURIComponent(value));
         }
     });
     const queryString = urlQuery.toString();
@@ -237,6 +240,9 @@ var CommonHeaders;
 export function fixCacheHeaderForHtmlPages(rawPath, headers) {
     // We don't want to cache error pages
     if (rawPath === "/404" || rawPath === "/500") {
+        if (process.env.OPEN_NEXT_DANGEROUSLY_SET_ERROR_HEADERS === "true") {
+            return;
+        }
         headers[CommonHeaders.CACHE_CONTROL] =
             "private, no-cache, no-store, max-age=0, must-revalidate";
         return;
@@ -268,7 +274,9 @@ export function fixSWRCacheHeader(headers) {
  * @__PURE__
  */
 export function addOpenNextHeader(headers) {
-    headers["X-OpenNext"] = "1";
+    if (NextConfig.poweredByHeader) {
+        headers["X-OpenNext"] = "1";
+    }
     if (globalThis.openNextDebug) {
         headers["X-OpenNext-Version"] = globalThis.openNextVersion;
         headers["X-OpenNext-RequestId"] = globalThis.__als.getStore()?.requestId;
@@ -383,7 +391,8 @@ export function fixISRHeaders(headers) {
         // 31536000 is the default s-maxage value for SSG pages
         if (sMaxAge && sMaxAge !== 31536000) {
             const remainingTtl = Math.max(sMaxAge - age, 1);
-            headers[CommonHeaders.CACHE_CONTROL] = `s-maxage=${remainingTtl}, stale-while-revalidate=2592000`;
+            headers[CommonHeaders.CACHE_CONTROL] =
+                `s-maxage=${remainingTtl}, stale-while-revalidate=2592000`;
         }
     }
     if (headers[CommonHeaders.NEXT_CACHE] !== "STALE")

package/dist/core/routingHandler.d.ts

@@ -1,4 +1,4 @@
-import { InternalEvent, InternalResult, Origin } from "../types/open-next";
+import type { InternalEvent, InternalResult, Origin } from "../types/open-next";
 export interface MiddlewareOutputEvent {
     internalEvent: InternalEvent;
     isExternalRewrite: boolean;

package/dist/core/routingHandler.js

@@ -30,7 +30,7 @@ function applyMiddlewareHeaders(eventHeaders, middlewareHeaders, setPrefix = tru
     });
 }
 export default async function routingHandler(event) {
-    const nextHeaders = addNextConfigHeaders(event, ConfigHeaders) ?? {};
+    const nextHeaders = addNextConfigHeaders(event, ConfigHeaders);
     let internalEvent = fixDataPage(event, BuildId);
     if ("statusCode" in internalEvent) {
         return internalEvent;

package/dist/helpers/withCloudflare.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions, OpenNextConfig, RouteTemplate, SplittedFunctionOptions } from "../types/open-next";
+import type { FunctionOptions, OpenNextConfig, RouteTemplate, SplittedFunctionOptions } from "../types/open-next";
 type CloudflareCompatibleFunction<Placement extends "regional" | "global"> = Placement extends "regional" ? FunctionOptions & {
     placement: "regional";
 } : {

package/dist/helpers/withSST.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions, OpenNextConfig, RouteTemplate } from "../types/open-next";
+import type { FunctionOptions, OpenNextConfig, RouteTemplate } from "../types/open-next";
 type SSTCompatibleFunction = FunctionOptions & {
     override?: {
         wrapper?: "aws-lambda-streaming" | "aws-lambda";

package/dist/http/openNextResponse.d.ts

@@ -2,9 +2,11 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import type { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from "http";
-import { Socket } from "net";
-import { Transform, TransformCallback, Writable } from "stream";
+import type { Socket } from "net";
+import type { TransformCallback, Writable } from "stream";
+import { Transform } from "stream";
 export interface StreamCreator {
     writeHeaders(prelude: {
         statusCode: number;
@@ -65,6 +67,11 @@ export declare class OpenNextNodeResponse extends Transform implements ServerRes
     private _internalWrite;
     _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
     _flush(callback: TransformCallback): void;
+    /**
+     * New method in Node 18.15+
+     * There are probably not used right now in Next.js, but better be safe than sorry
+     */
+    setHeaders(headers: Headers | Map<string, number | string | readonly string[]>): this;
     /**
      * Next specific methods
      * On earlier versions of next.js, those methods are mandatory to make everything work
@@ -75,4 +82,5 @@ export declare class OpenNextNodeResponse extends Transform implements ServerRes
     body(value: string): this;
     onClose(callback: () => void): void;
     redirect(destination: string, statusCode: number): this;
+    private fixHeadersForError;
 }

package/dist/http/openNextResponse.js

@@ -141,6 +141,7 @@ export class OpenNextNodeResponse extends Transform {
                     : [...initialCookies, ...this._cookies];
         }
         this.fixHeaders(this.headers);
+        this.fixHeadersForError();
         // We need to fix the set-cookie header here
         this.headers[SET_COOKIE_HEADER] = this._cookies;
         const parsedHeaders = parseHeaders(this.headers);
@@ -206,6 +207,7 @@ export class OpenNextNodeResponse extends Transform {
     getFixedHeaders() {
         // Do we want to apply this on writeHead?
         this.fixHeaders(this.headers);
+        this.fixHeadersForError();
         // This way we ensure that the cookies are correct
         this.headers[SET_COOKIE_HEADER] = this._cookies;
         return this.headers;
@@ -243,6 +245,16 @@ export class OpenNextNodeResponse extends Transform {
         }
         callback();
     }
+    /**
+     * New method in Node 18.15+
+     * There are probably not used right now in Next.js, but better be safe than sorry
+     */
+    setHeaders(headers) {
+        headers.forEach((value, key) => {
+            this.setHeader(key, Array.isArray(value) ? value : value.toString());
+        });
+        return this;
+    }
     /**
      * Next specific methods
      * On earlier versions of next.js, those methods are mandatory to make everything work
@@ -278,4 +290,19 @@ export class OpenNextNodeResponse extends Transform {
         //TODO: test to see if we need to call end here
         return this;
     }
+    // For some reason, next returns the 500 error page with some cache-control headers
+    // We need to fix that
+    fixHeadersForError() {
+        if (process.env.OPEN_NEXT_DANGEROUSLY_SET_ERROR_HEADERS === "true") {
+            return;
+        }
+        // We only check for 404 and 500 errors
+        // The rest should be errors that are handled by the user and they should set the cache headers themselves
+        if (this.statusCode === 404 || this.statusCode === 500) {
+            // For some reason calling this.setHeader("Cache-Control", "no-cache, no-store, must-revalidate") does not work here
+            // The function is not even called, i'm probably missing something obvious
+            this.headers["cache-control"] =
+                "private, no-cache, no-store, max-age=0, must-revalidate";
+        }
+    }
 }

package/dist/http/request.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import http from "node:http";
 export declare class IncomingMessage extends http.IncomingMessage {
     constructor({ method, url, headers, body, remoteAddress, }: {

package/dist/http/util.d.ts

@@ -1,4 +1,4 @@
-import http from "node:http";
+import type http from "node:http";
 export declare const parseHeaders: (headers?: http.OutgoingHttpHeader[] | http.OutgoingHttpHeaders) => Record<string, string>;
 export declare const convertHeader: (header: http.OutgoingHttpHeader) => string;
 export declare function parseCookies(cookies?: string | string[]): string[] | undefined;

package/dist/{converters → overrides/converters}/aws-apigw-v1.d.ts

@@ -1,3 +1,3 @@
-import type { Converter, InternalEvent, InternalResult } from "../types/open-next";
+import type { Converter, InternalEvent, InternalResult } from "../../types/open-next";
 declare const _default: Converter<InternalEvent, InternalResult>;
 export default _default;

package/dist/{converters → overrides/converters}/aws-apigw-v1.js

@@ -1,5 +1,5 @@
-import { fromReadableStream } from "../utils/stream";
-import { debug } from "../adapters/logger";
+import { fromReadableStream } from "../../utils/stream";
+import { debug } from "../../adapters/logger";
 import { removeUndefinedFromQuery } from "./utils";
 function normalizeAPIGatewayProxyEventHeaders(event) {
     event.multiValueHeaders;

package/dist/{converters → overrides/converters}/aws-apigw-v2.d.ts

@@ -1,3 +1,3 @@
-import type { Converter, InternalEvent, InternalResult } from "../types/open-next";
+import type { Converter, InternalEvent, InternalResult } from "../../types/open-next";
 declare const _default: Converter<InternalEvent, InternalResult>;
 export default _default;

package/dist/{converters → overrides/converters}/aws-apigw-v2.js

@@ -1,7 +1,7 @@
-import { parseCookies } from "../http/util";
-import { fromReadableStream } from "../utils/stream";
-import { debug } from "../adapters/logger";
-import { convertToQuery } from "../core/routing/util";
+import { parseCookies } from "../../http/util";
+import { fromReadableStream } from "../../utils/stream";
+import { debug } from "../../adapters/logger";
+import { convertToQuery } from "../../core/routing/util";
 import { removeUndefinedFromQuery } from "./utils";
 // Not sure which one is reallly needed as this is not documented anywhere but server actions redirect are not working without this, it causes a 500 error from cloudfront itself with a 'x-amzErrortype: InternalFailure' header
 const CloudFrontBlacklistedHeaders = [

package/dist/{converters → overrides/converters}/aws-cloudfront.d.ts

@@ -1,3 +1,3 @@
-import type { Converter, InternalEvent, InternalResult } from "../types/open-next";
+import type { Converter, InternalEvent, InternalResult } from "../../types/open-next";
 declare const _default: Converter<InternalEvent, InternalResult>;
 export default _default;

package/dist/{converters → overrides/converters}/aws-cloudfront.js

@@ -1,7 +1,7 @@
-import { parseCookies } from "../http/util";
-import { fromReadableStream } from "../utils/stream";
-import { debug } from "../adapters/logger";
-import { convertRes, convertToQuery, convertToQueryString, createServerResponse, proxyRequest, } from "../core/routing/util";
+import { parseCookies } from "../../http/util";
+import { fromReadableStream } from "../../utils/stream";
+import { debug } from "../../adapters/logger";
+import { convertRes, convertToQuery, convertToQueryString, createServerResponse, proxyRequest, } from "../../core/routing/util";
 const CloudFrontBlacklistedHeaders = [
     // Disallowed headers, see: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/edge-function-restrictions-all.html#function-restrictions-disallowed-headers
     "connection",
@@ -100,11 +100,9 @@ function convertToCloudfrontHeaders(headers, directResponse) {
     return cloudfrontHeaders;
 }
 async function convertToCloudFrontRequestResult(result, originalRequest) {
-    let responseHeaders = result.type === "middleware"
-        ? result.internalEvent.headers
-        : result.headers;
     if (result.type === "middleware") {
         const { method, clientIp, origin } = originalRequest.Records[0].cf.request;
+        const responseHeaders = result.internalEvent.headers;
         // Handle external rewrite
         if (result.isExternalRewrite) {
             const serverResponse = createServerResponse(result.internalEvent, {});
@@ -154,6 +152,7 @@ async function convertToCloudFrontRequestResult(result, originalRequest) {
         return response;
     }
     const body = await fromReadableStream(result.body, result.isBase64Encoded);
+    const responseHeaders = result.headers;
     const response = {
         status: result.statusCode.toString(),
         statusDescription: "OK",

package/dist/{converters → overrides/converters}/dummy.d.ts

@@ -1,4 +1,4 @@
-import { Converter } from "../types/open-next";
+import type { Converter } from "../../types/open-next";
 type DummyEventOrResult = {
     type: "dummy";
     original: any;

package/dist/overrides/converters/edge.d.ts

@@ -0,0 +1,9 @@
+import type { Converter, InternalEvent, InternalResult } from "../../types/open-next";
+import type { MiddlewareOutputEvent } from "../../core/routingHandler";
+declare global {
+    var __dangerous_ON_edge_converter_returns_request: boolean | undefined;
+}
+declare const converter: Converter<InternalEvent, InternalResult | ({
+    type: "middleware";
+} & MiddlewareOutputEvent)>;
+export default converter;

package/dist/{converters → overrides/converters}/edge.js

@@ -1,5 +1,5 @@
 import { Buffer } from "node:buffer";
-import { parseCookies } from "../http/util";
+import { parseCookies } from "../../http/util";
 const converter = {
     convertFrom: async (event) => {
         const searchParams = new URL(event.url).searchParams;
@@ -52,7 +52,7 @@ const converter = {
                     url = `https://${result.internalEvent.headers.host}${url}`;
                 }
             }
-            const req = new Request(url, {
+            const request = new Request(url, {
                 body: result.internalEvent.body,
                 method: result.internalEvent.method,
                 headers: {
@@ -60,12 +60,15 @@ const converter = {
                     "x-forwarded-host": result.internalEvent.headers.host,
                 },
             });
+            if (globalThis.__dangerous_ON_edge_converter_returns_request === true) {
+                return request;
+            }
             const cfCache = (result.isISR ||
                 result.internalEvent.rawPath.startsWith("/_next/image")) &&
                 process.env.DISABLE_CACHE !== "true"
                 ? { cacheEverything: true }
                 : {};
-            return fetch(req, {
+            return fetch(request, {
                 // This is a hack to make sure that the response is cached by Cloudflare
                 // See https://developers.cloudflare.com/workers/examples/cache-using-fetch/#caching-html-resources
                 // @ts-expect-error - This is a Cloudflare specific option

package/dist/{converters → overrides/converters}/node.d.ts

@@ -1,3 +1,3 @@
-import type { Converter } from "../types/open-next";
+import type { Converter } from "../../types/open-next";
 declare const converter: Converter;
 export default converter;

package/dist/{converters → overrides/converters}/node.js

@@ -1,4 +1,4 @@
-import { parseCookies } from "../http/util";
+import { parseCookies } from "../../http/util";
 const converter = {
     convertFrom: async (req) => {
         const body = await new Promise((resolve) => {

package/dist/overrides/converters/sqs-revalidate.d.ts

@@ -0,0 +1,4 @@
+import type { Converter } from "../../types/open-next";
+import type { RevalidateEvent } from "../../adapters/revalidate";
+declare const converter: Converter<RevalidateEvent, RevalidateEvent>;
+export default converter;

package/dist/overrides/imageLoader/dummy.d.ts

@@ -0,0 +1,3 @@
+import type { ImageLoader } from "../../types/open-next";
+declare const dummyLoader: ImageLoader;
+export default dummyLoader;

package/dist/overrides/imageLoader/dummy.js

@@ -0,0 +1,8 @@
+import { FatalError } from "../../utils/error";
+const dummyLoader = {
+    name: "dummy",
+    load: async (_) => {
+        throw new FatalError("Dummy loader is not implemented");
+    },
+};
+export default dummyLoader;

package/dist/overrides/imageLoader/host.d.ts

@@ -1,3 +1,3 @@
-import { ImageLoader } from "../../types/open-next";
+import type { ImageLoader } from "../../types/open-next";
 declare const hostLoader: ImageLoader;
 export default hostLoader;

package/dist/overrides/imageLoader/s3.d.ts

@@ -1,3 +1,3 @@
-import { ImageLoader } from "../../types/open-next";
+import type { ImageLoader } from "../../types/open-next";
 declare const s3Loader: ImageLoader;
 export default s3Loader;

package/dist/overrides/incrementalCache/dummy.d.ts

@@ -0,0 +1,3 @@
+import type { IncrementalCache } from "./types";
+declare const dummyIncrementalCache: IncrementalCache;
+export default dummyIncrementalCache;