@opennextjs/aws 3.5.4 → 3.5.6

package/dist/build/createServerBundle.js

@@ -14,8 +14,7 @@ import { copyMiddlewareResources, generateEdgeBundle, } from "./edge/createEdgeB
 import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
 import { applyCodePatches } from "./patch/codePatcher.js";
-import { patchFetchCacheForISR, patchUnstableCacheForISR, } from "./patch/patchFetchCacheISR.js";
-import { patchFetchCacheSetMissingWaitUntil } from "./patch/patchFetchCacheWaitUntil.js";
+import { patchEnvVars, patchFetchCacheForISR, patchFetchCacheSetMissingWaitUntil, patchNextServer, patchUnstableCacheForISR, } from "./patch/patches/index.js";
 export async function createServerBundle(options, codeCustomization) {
     const { config } = options;
     const foundRoutes = new Set();
@@ -120,6 +119,8 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
         patchFetchCacheSetMissingWaitUntil,
         patchFetchCacheForISR,
         patchUnstableCacheForISR,
+        patchNextServer,
+        patchEnvVars,
         ...additionalCodePatches,
     ]);
     // Build Lambda code

package/dist/build/patch/patches/index.d.ts

@@ -0,0 +1,4 @@
+export { envVarRuleCreator, patchEnvVars } from "./patchEnvVar.js";
+export { patchNextServer } from "./patchNextServer.js";
+export { patchFetchCacheForISR, patchUnstableCacheForISR, } from "./patchFetchCacheISR.js";
+export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";

package/dist/build/patch/patches/index.js

@@ -0,0 +1,4 @@
+export { envVarRuleCreator, patchEnvVars } from "./patchEnvVar.js";
+export { patchNextServer } from "./patchNextServer.js";
+export { patchFetchCacheForISR, patchUnstableCacheForISR, } from "./patchFetchCacheISR.js";
+export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";

package/dist/build/patch/patches/patchEnvVar.d.ts

@@ -0,0 +1,10 @@
+import type { CodePatcher } from "../codePatcher";
+/**
+ * Creates a rule to replace `process.env.${envVar}` by `value` in the condition of if statements
+ * This is used to avoid loading unnecessary deps at runtime
+ * @param envVar The env var that we want to replace
+ * @param value The value that we want to replace it with
+ * @returns
+ */
+export declare const envVarRuleCreator: (envVar: string, value: string) => string;
+export declare const patchEnvVars: CodePatcher;

package/dist/build/patch/patches/patchEnvVar.js

@@ -0,0 +1,52 @@
+import { createPatchCode } from "../astCodePatcher.js";
+/**
+ * Creates a rule to replace `process.env.${envVar}` by `value` in the condition of if statements
+ * This is used to avoid loading unnecessary deps at runtime
+ * @param envVar The env var that we want to replace
+ * @param value The value that we want to replace it with
+ * @returns
+ */
+export const envVarRuleCreator = (envVar, value) => `
+rule:
+  kind: member_expression
+  pattern: process.env.${envVar}
+  inside:
+    kind: parenthesized_expression
+    stopBy: end
+    inside:
+      kind: if_statement
+fix:
+  '${value}'
+`;
+export const patchEnvVars = {
+    name: "patch-env-vars",
+    patches: [
+        // This patch will set the `NEXT_RUNTIME` env var to "node" to avoid loading unnecessary edge deps at runtime
+        {
+            versions: ">=15.0.0",
+            field: {
+                pathFilter: /module\.compiled\.js$/,
+                contentFilter: /process\.env\.NEXT_RUNTIME/,
+                patchCode: createPatchCode(envVarRuleCreator("NEXT_RUNTIME", '"node"')),
+            },
+        },
+        // This patch will set `NODE_ENV` to production to avoid loading unnecessary dev deps at runtime
+        {
+            versions: ">=15.0.0",
+            field: {
+                pathFilter: /(module\.compiled|react\/index|react\/jsx-runtime|react-dom\/index)\.js$/,
+                contentFilter: /process\.env\.NODE_ENV/,
+                patchCode: createPatchCode(envVarRuleCreator("NODE_ENV", '"production"')),
+            },
+        },
+        // This patch will set `TURBOPACK` env to false to avoid loading turbopack related deps at runtime
+        {
+            versions: ">=15.0.0",
+            field: {
+                pathFilter: /module\.compiled\.js$/,
+                contentFilter: /process\.env\.TURBOPACK/,
+                patchCode: createPatchCode(envVarRuleCreator("TURBOPACK", "false")),
+            },
+        },
+    ],
+};

package/dist/build/patch/{patchFetchCacheISR.d.ts → patches/patchFetchCacheISR.d.ts}

@@ -1,4 +1,4 @@
-import type { CodePatcher } from "./codePatcher";
+import type { CodePatcher } from "../codePatcher.js";
 export declare const fetchRule = "\nrule:\n  kind: member_expression\n  pattern: $WORK_STORE.isOnDemandRevalidate\n  inside:\n    kind: ternary_expression\n    all:\n      - has: {kind: 'null'}\n      - has: \n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n    inside:\n        kind: variable_declarator\n\nfix:\n  ($WORK_STORE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
 export declare const unstable_cacheRule = "\nrule:\n  kind: member_expression\n  pattern: $STORE_OR_CACHE.isOnDemandRevalidate\n  inside:\n    kind: if_statement\n    stopBy: end\n    has:\n      kind: statement_block\n      has:\n        kind: variable_declarator\n        has: \n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n        stopBy: end\nfix:\n  ($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
 export declare const patchFetchCacheForISR: CodePatcher;

package/dist/build/patch/{patchFetchCacheISR.js → patches/patchFetchCacheISR.js}

@@ -1,6 +1,6 @@
 import { Lang } from "@ast-grep/napi";
-import { getCrossPlatformPathRegex } from "../../utils/regex.js";
-import { createPatchCode } from "./astCodePatcher.js";
+import { getCrossPlatformPathRegex } from "../../../utils/regex.js";
+import { createPatchCode } from "../astCodePatcher.js";
 export const fetchRule = `
 rule:
   kind: member_expression

package/dist/build/patch/{patchFetchCacheWaitUntil.d.ts → patches/patchFetchCacheWaitUntil.d.ts}

@@ -1,3 +1,3 @@
-import type { CodePatcher } from "./codePatcher";
+import type { CodePatcher } from "../codePatcher.js";
 export declare const rule = "\nrule:\n  kind: call_expression\n  pattern: $PROMISE\n  all:\n    - has: { pattern: $_.arrayBuffer().then, stopBy: end }\n    - has: { pattern: \"Buffer.from\", stopBy: end }\n    - any:\n        - inside:\n            kind: sequence_expression\n            inside:\n                kind: return_statement\n        - inside:\n            kind: expression_statement\n            precedes:\n                kind: return_statement\n    - has: { pattern: $_.FETCH, stopBy: end }\n\nfix: |\n  globalThis.__openNextAls?.getStore()?.pendingPromiseRunner.add($PROMISE)\n";
 export declare const patchFetchCacheSetMissingWaitUntil: CodePatcher;

package/dist/build/patch/{patchFetchCacheWaitUntil.js → patches/patchFetchCacheWaitUntil.js}

@@ -1,5 +1,5 @@
-import { getCrossPlatformPathRegex } from "../../utils/regex.js";
-import { createPatchCode } from "./astCodePatcher.js";
+import { getCrossPlatformPathRegex } from "../../../utils/regex.js";
+import { createPatchCode } from "../astCodePatcher.js";
 export const rule = `
 rule:
   kind: call_expression

package/dist/build/patch/patches/patchNextServer.d.ts

@@ -0,0 +1,5 @@
+import type { CodePatcher } from "../codePatcher.js";
+export declare const minimalRule = "\nrule:\n  kind: member_expression\n  pattern: process.env.NEXT_MINIMAL\n  any:\n    - inside:\n        kind: parenthesized_expression\n        stopBy: end\n        inside:\n          kind: if_statement\n          any:\n            - inside:\n                kind: statement_block\n                inside:\n                  kind: method_definition\n                  any:\n                    - has: {kind: property_identifier, field: name, regex: runEdgeFunction}\n                    - has: {kind: property_identifier, field: name, regex: runMiddleware}\n                    - has: {kind: property_identifier, field: name, regex: imageOptimizer}\n            - has:\n                kind: statement_block\n                has:\n                  kind: expression_statement\n                  pattern: res.statusCode = 400;\nfix:\n  'true'\n";
+export declare const disablePreloadingRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: if_statement\n    any: \n      - has: \n          kind: member_expression\n          pattern: this.nextConfig.experimental.preloadEntriesOnStart\n          stopBy: end\n      - has: \n          kind: binary_expression\n          pattern: appDocumentPreloading === true\n          stopBy: end\nfix:\n  '{}'\n";
+export declare const removeMiddlewareManifestRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: method_definition\n    has:\n      kind: property_identifier\n      regex: getMiddlewareManifest\nfix:\n  '{return null;}'\n";
+export declare const patchNextServer: CodePatcher;

package/dist/build/patch/patches/patchNextServer.js

@@ -0,0 +1,91 @@
+import { createPatchCode } from "../astCodePatcher.js";
+// This rule will replace the `NEXT_MINIMAL` env variable with true in multiple places to avoid executing unwanted path (i.e. next middleware, edge functions and image optimization)
+export const minimalRule = `
+rule:
+  kind: member_expression
+  pattern: process.env.NEXT_MINIMAL
+  any:
+    - inside:
+        kind: parenthesized_expression
+        stopBy: end
+        inside:
+          kind: if_statement
+          any:
+            - inside:
+                kind: statement_block
+                inside:
+                  kind: method_definition
+                  any:
+                    - has: {kind: property_identifier, field: name, regex: runEdgeFunction}
+                    - has: {kind: property_identifier, field: name, regex: runMiddleware}
+                    - has: {kind: property_identifier, field: name, regex: imageOptimizer}
+            - has:
+                kind: statement_block
+                has:
+                  kind: expression_statement
+                  pattern: res.statusCode = 400;
+fix:
+  'true'
+`;
+// This rule will disable the background preloading of route done by NextServer by default during the creation of NextServer
+export const disablePreloadingRule = `
+rule:
+  kind: statement_block
+  inside:
+    kind: if_statement
+    any: 
+      - has: 
+          kind: member_expression
+          pattern: this.nextConfig.experimental.preloadEntriesOnStart
+          stopBy: end
+      - has: 
+          kind: binary_expression
+          pattern: appDocumentPreloading === true
+          stopBy: end
+fix:
+  '{}'
+`;
+// This rule is mostly for splitted edge functions so that we don't try to match them on the other non edge functions
+export const removeMiddlewareManifestRule = `
+rule:
+  kind: statement_block
+  inside:
+    kind: method_definition
+    has:
+      kind: property_identifier
+      regex: getMiddlewareManifest
+fix:
+  '{return null;}'
+`;
+export const patchNextServer = {
+    name: "patch-next-server",
+    patches: [
+        // Skip executing next middleware, edge functions and image optimization inside NextServer
+        {
+            versions: ">=15.0.0",
+            field: {
+                pathFilter: /next-server\.(js)$/,
+                contentFilter: /process\.env\.NEXT_MINIMAL/,
+                patchCode: createPatchCode(minimalRule),
+            },
+        },
+        // Disable Next background preloading done at creation of `NetxServer`
+        {
+            versions: ">=15.0.0",
+            field: {
+                pathFilter: /next-server\.(js)$/,
+                contentFilter: /this\.nextConfig\.experimental\.preloadEntriesOnStart/,
+                patchCode: createPatchCode(disablePreloadingRule),
+            },
+        },
+        // Don't match edge functions in `NextServer`
+        {
+            versions: ">=15.0.0",
+            field: {
+                pathFilter: /next-server\.(js)$/,
+                contentFilter: /getMiddlewareManifest/,
+                patchCode: createPatchCode(removeMiddlewareManifestRule),
+            },
+        },
+    ],
+};

package/dist/build/validateConfig.js

@@ -6,6 +6,7 @@ const compatibilityMatrix = {
         "aws-cloudfront",
         "sqs-revalidate",
     ],
+    "aws-lambda-compressed": ["aws-apigw-v2"],
     "aws-lambda-streaming": ["aws-apigw-v2"],
     cloudflare: ["edge"],
     "cloudflare-edge": ["edge"],

package/dist/core/createMainHandler.js

@@ -10,6 +10,8 @@ export async function createMainHandler() {
         : config.default;
     globalThis.serverId = generateUniqueId();
     globalThis.openNextConfig = config;
+    // If route preloading behavior is set to start, it will wait for every single route to be preloaded before even creating the main handler.
+    await globalThis.__next_route_preloader("start");
     // Default queue
     globalThis.queue = await resolveQueue(thisFunction.override?.queue);
     globalThis.incrementalCache = await resolveIncrementalCache(thisFunction.override?.incrementalCache);

package/dist/core/requestHandler.js

@@ -2,7 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { IncomingMessage } from "../http/index.js";
 import { runWithOpenNextRequestContext } from "../utils/promise";
 import { NextConfig } from "../adapters/config/index";
-import { debug, error, warn } from "../adapters/logger";
+import { debug, error } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
 import { constructNextUrl, convertRes, convertToQuery, createServerResponse, } from "./routing/util";
 import routingHandler, { INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
@@ -19,6 +19,7 @@ export async function openNextHandler(internalEvent, options) {
         isISRRevalidation: initialHeaders["x-isr"] === "1",
         waitUntil: options?.waitUntil,
     }, async () => {
+        await globalThis.__next_route_preloader("waitUntil");
         if (initialHeaders["x-forwarded-host"]) {
             initialHeaders.host = initialHeaders["x-forwarded-host"];
         }
@@ -39,12 +40,7 @@ export async function openNextHandler(internalEvent, options) {
             ...internalHeaders,
         };
         //#override withRouting
-        try {
-            routingResult = await routingHandler(internalEvent);
-        }
-        catch (e) {
-            warn("Routing failed.", e);
-        }
+        routingResult = await routingHandler(internalEvent);
         //#endOverride
         const headers = "type" in routingResult
             ? routingResult.headers

package/dist/core/routing/matcher.js

@@ -114,19 +114,13 @@ 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 toDestinationPath = compile(escapeRegex(pathname, { isPath: true }));
         const toDestinationHost = compile(escapeRegex(hostname));
-        const toDestinationQuery = compile(escapeRegex(encodePlusQueryString));
+        const toDestinationQuery = compile(escapeRegex(queryString));
         const params = {
             // params for the source
-            ...getParamsFromSource(match(escapeRegex(rewrite.source)))(pathToUse),
+            ...getParamsFromSource(match(escapeRegex(rewrite.source, { isPath: true })))(pathToUse),
             // params for the has
             ...rewrite.has?.reduce((acc, cur) => {
                 return Object.assign(acc, computeHas(cur));
@@ -137,7 +131,7 @@ export function handleRewrites(event, rewrites) {
             }, {}),
         };
         const isUsingParams = Object.keys(params).length > 0;
-        let rewrittenQuery = encodePlusQueryString;
+        let rewrittenQuery = queryString;
         let rewrittenHost = hostname;
         let rewrittenPath = pathname;
         if (isUsingParams) {

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

@@ -7,5 +7,12 @@ type Middleware = (request: Request) => Response | Promise<Response>;
 type MiddlewareLoader = () => Promise<{
     default: Middleware;
 }>;
-export declare function handleMiddleware(internalEvent: InternalEvent, middlewareLoader?: MiddlewareLoader): Promise<MiddlewareEvent | InternalResult>;
+/**
+ *
+ * @param internalEvent the internal event
+ * @param initialSearch the initial query string as it was received in the handler
+ * @param middlewareLoader Only used for unit test
+ * @returns `Promise<MiddlewareEvent | InternalResult>`
+ */
+export declare function handleMiddleware(internalEvent: InternalEvent, initialSearch: string, middlewareLoader?: MiddlewareLoader): Promise<MiddlewareEvent | InternalResult>;
 export {};

package/dist/core/routing/middleware.js

@@ -1,14 +1,7 @@
 import { FunctionsConfigManifest, MiddlewareManifest, NextConfig, PrerenderManifest, } from "../../adapters/config/index.js";
 import { emptyReadableStream } from "../../utils/stream.js";
 import { localizePath } from "./i18n/index.js";
-//NOTE: we should try to avoid importing stuff from next as much as possible
-// every release of next could break this
-// const { run } = require("next/dist/server/web/sandbox");
-// const { getCloneableBody } = require("next/dist/server/body-streams");
-// const {
-//   signalFromNodeResponse,
-// } = require("next/dist/server/web/spec-extension/adapters/next-request");
-import { convertBodyToReadableStream, convertToQueryString, getMiddlewareMatch, isExternal, } from "./util.js";
+import { convertBodyToReadableStream, getMiddlewareMatch, isExternal, } from "./util.js";
 const middlewareManifest = MiddlewareManifest;
 const functionsConfigManifest = FunctionsConfigManifest;
 const middleMatch = getMiddlewareMatch(middlewareManifest, functionsConfigManifest);
@@ -16,12 +9,14 @@ 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, middlewareLoader = defaultMiddlewareLoader) {
+/**
+ *
+ * @param internalEvent the internal event
+ * @param initialSearch the initial query string as it was received in the handler
+ * @param middlewareLoader Only used for unit test
+ * @returns `Promise<MiddlewareEvent | InternalResult>`
+ */
+export async function handleMiddleware(internalEvent, initialSearch, middlewareLoader = defaultMiddlewareLoader) {
     const headers = internalEvent.headers;
     // We bypass the middleware if the request is internal
     // We should only do that if the request has the correct `x-prerender-revalidate` header
@@ -36,7 +31,7 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     if (!hasMatch)
         return internalEvent;
     const initialUrl = new URL(normalizedPath, internalEvent.url);
-    initialUrl.search = convertToQueryString(internalEvent.query);
+    initialUrl.search = initialSearch;
     const url = initialUrl.href;
     const middleware = await middlewareLoader();
     const result = await middleware.default({
@@ -117,13 +112,11 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     // If the middleware returned a Rewrite, set the `url` to the pathname of the rewrite
     // NOTE: the header was added to `req` from above
     const rewriteUrl = responseHeaders.get("x-middleware-rewrite");
-    let rewritten = false;
     let isExternalRewrite = false;
     let middlewareQueryString = internalEvent.query;
     let newUrl = internalEvent.url;
     if (rewriteUrl) {
         newUrl = rewriteUrl;
-        rewritten = true;
         // If not a string, it should probably throw
         if (isExternal(newUrl, internalEvent.headers.host)) {
             isExternalRewrite = true;

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

@@ -8,7 +8,7 @@ import type { InternalEvent, InternalResult, RoutingResult, StreamCreator } from
  * @__PURE__
  */
 export declare function isExternal(url?: string, host?: string): boolean;
-export declare function convertFromQueryString(query: string): Record<string, string>;
+export declare function convertFromQueryString(query: string): Record<string, string | string[]>;
 /**
  *
  * @__PURE__
@@ -38,6 +38,7 @@ export declare function convertRes(res: OpenNextNodeResponse): InternalResult;
  * Make sure that multi-value query parameters are transformed to
  * ?key=value1&key=value2&... so that Next converts those parameters
  * to an array when reading the query parameters
+ * query should be properly encoded before using this function
  * @__PURE__
  */
 export declare function convertToQueryString(query: Record<string, string | string[]>): string;
@@ -56,7 +57,9 @@ export declare function getMiddlewareMatch(middlewareManifest: MiddlewareManifes
  *
  * @__PURE__
  */
-export declare function escapeRegex(str: string): string;
+export declare function escapeRegex(str: string, { isPath }?: {
+    isPath?: boolean;
+}): string;
 /**
  *
  * @__PURE__

package/dist/core/routing/util.js

@@ -2,7 +2,7 @@ import crypto from "node:crypto";
 import { Readable } from "node:stream";
 import { BuildId, HtmlPages, NextConfig } from "../../adapters/config/index.js";
 import { OpenNextNodeResponse } from "../../http/openNextResponse.js";
-import { parseHeaders } from "../../http/util.js";
+import { getQueryFromIterator, parseHeaders } from "../../http/util.js";
 import { debug, error } from "../../adapters/logger.js";
 import { isBinaryContentType } from "../../utils/binary.js";
 import { localizePath } from "./i18n/index.js";
@@ -24,11 +24,10 @@ export function convertFromQueryString(query) {
     if (query === "")
         return {};
     const queryParts = query.split("&");
-    return queryParts.reduce((acc, part) => {
-        const [key, value] = part.split("=");
-        acc[key] = value;
-        return acc;
-    }, {});
+    return getQueryFromIterator(queryParts.map((p) => {
+        const [key, value] = p.split("=");
+        return [key, value];
+    }));
 }
 /**
  *
@@ -99,23 +98,20 @@ export function convertRes(res) {
  * Make sure that multi-value query parameters are transformed to
  * ?key=value1&key=value2&... so that Next converts those parameters
  * to an array when reading the query parameters
+ * query should be properly encoded before using this function
  * @__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();
+    const queryStrings = [];
     Object.entries(query).forEach(([key, value]) => {
         if (Array.isArray(value)) {
-            value.forEach((entry) => urlQuery.append(key, decodeURIComponent(entry)));
+            value.forEach((entry) => queryStrings.push(`${key}=${entry}`));
         }
         else {
-            urlQuery.append(key, decodeURIComponent(value));
+            queryStrings.push(`${key}=${value}`);
         }
     });
-    const queryString = urlQuery.toString();
-    return queryString ? `?${queryString}` : "";
+    return queryStrings.length > 0 ? `?${queryStrings.join("&")}` : "";
 }
 /**
  * Given a raw query string, returns a record with key value-array pairs
@@ -148,11 +144,12 @@ export function getMiddlewareMatch(middlewareManifest, functionsManifest) {
  *
  * @__PURE__
  */
-export function escapeRegex(str) {
-    return str
+export function escapeRegex(str, { isPath } = {}) {
+    const result = str
         .replaceAll("(.)", "_µ1_")
         .replaceAll("(..)", "_µ2_")
         .replaceAll("(...)", "_µ3_");
+    return isPath ? result : result.replaceAll("+", "_µ4_");
 }
 /**
  *
@@ -162,7 +159,8 @@ export function unescapeRegex(str) {
     return str
         .replaceAll("_µ1_", "(.)")
         .replaceAll("_µ2_", "(..)")
-        .replaceAll("_µ3_", "(...)");
+        .replaceAll("_µ3_", "(...)")
+        .replaceAll("_µ4_", "+");
 }
 /**
  * @__PURE__
@@ -202,7 +200,9 @@ export function fixCacheHeaderForHtmlPages(internalEvent, headers) {
     const localizedPath = localizePath(internalEvent);
     // WORKAROUND: `NextServer` does not set cache headers for HTML pages
     // https://opennext.js.org/aws/v2/advanced/workaround#workaround-nextserver-does-not-set-cache-headers-for-html-pages
-    if (HtmlPages.includes(localizedPath)) {
+    // Requests containing an `x-middleware-prefetch` header must not be cached
+    if (HtmlPages.includes(localizedPath) &&
+        !internalEvent.headers["x-middleware-prefetch"]) {
         headers[CommonHeaders.CACHE_CONTROL] =
             "public, max-age=0, s-maxage=31536000, must-revalidate";
     }

package/dist/core/routingHandler.js

@@ -1,5 +1,5 @@
 import { BuildId, ConfigHeaders, NextConfig, PrerenderManifest, RoutesManifest, } from "../adapters/config/index";
-import { debug } from "../adapters/logger";
+import { debug, error } from "../adapters/logger";
 import { cacheInterceptor } from "./routing/cacheInterceptor";
 import { detectLocale } from "./routing/i18n";
 import { fixDataPage, getNextConfigHeaders, handleFallbackFalse, handleRedirects, handleRewrites, } from "./routing/matcher";
@@ -32,121 +32,153 @@ function applyMiddlewareHeaders(eventHeaders, middlewareHeaders, setPrefix = tru
     });
 }
 export default async function routingHandler(event) {
-    // Add Next geo headers
-    for (const [openNextGeoName, nextGeoName] of Object.entries(geoHeaderToNextHeader)) {
-        const value = event.headers[openNextGeoName];
-        if (value) {
-            event.headers[nextGeoName] = value;
+    try {
+        // Add Next geo headers
+        for (const [openNextGeoName, nextGeoName] of Object.entries(geoHeaderToNextHeader)) {
+            const value = event.headers[openNextGeoName];
+            if (value) {
+                event.headers[nextGeoName] = value;
+            }
         }
-    }
-    // First we remove internal headers
-    // We don't want to allow users to set these headers
-    for (const key of Object.keys(event.headers)) {
-        if (key.startsWith(INTERNAL_HEADER_PREFIX) ||
-            key.startsWith(MIDDLEWARE_HEADER_PREFIX)) {
-            delete event.headers[key];
+        // First we remove internal headers
+        // We don't want to allow users to set these headers
+        for (const key of Object.keys(event.headers)) {
+            if (key.startsWith(INTERNAL_HEADER_PREFIX) ||
+                key.startsWith(MIDDLEWARE_HEADER_PREFIX)) {
+                delete event.headers[key];
+            }
         }
-    }
-    const nextHeaders = getNextConfigHeaders(event, ConfigHeaders);
-    let internalEvent = fixDataPage(event, BuildId);
-    if ("statusCode" in internalEvent) {
-        return internalEvent;
-    }
-    const redirect = handleRedirects(internalEvent, RoutesManifest.redirects);
-    if (redirect) {
-        debug("redirect", redirect);
-        return redirect;
-    }
-    const eventOrResult = await handleMiddleware(internalEvent);
-    const isResult = "statusCode" in eventOrResult;
-    if (isResult) {
-        return eventOrResult;
-    }
-    const middlewareResponseHeaders = eventOrResult.responseHeaders;
-    let isExternalRewrite = eventOrResult.isExternalRewrite ?? false;
-    // internalEvent is `InternalEvent | MiddlewareEvent`
-    internalEvent = eventOrResult;
-    if (!isExternalRewrite) {
-        // First rewrite to be applied
-        const beforeRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.beforeFiles);
-        internalEvent = beforeRewrites.internalEvent;
-        isExternalRewrite = beforeRewrites.isExternalRewrite;
-    }
-    const foundStaticRoute = staticRouteMatcher(internalEvent.rawPath);
-    const isStaticRoute = !isExternalRewrite && foundStaticRoute.length > 0;
-    if (!(isStaticRoute || isExternalRewrite)) {
-        // Second rewrite to be applied
-        const afterRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.afterFiles);
-        internalEvent = afterRewrites.internalEvent;
-        isExternalRewrite = afterRewrites.isExternalRewrite;
-    }
-    // We want to run this just before the dynamic route check
-    const { event: fallbackEvent, isISR } = handleFallbackFalse(internalEvent, PrerenderManifest);
-    internalEvent = fallbackEvent;
-    const foundDynamicRoute = dynamicRouteMatcher(internalEvent.rawPath);
-    const isDynamicRoute = !isExternalRewrite && foundDynamicRoute.length > 0;
-    if (!(isDynamicRoute || isStaticRoute || isExternalRewrite)) {
-        // Fallback rewrite to be applied
-        const fallbackRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.fallback);
-        internalEvent = fallbackRewrites.internalEvent;
-        isExternalRewrite = fallbackRewrites.isExternalRewrite;
-    }
-    // Api routes are not present in the routes manifest except if they're not behind /api
-    // /api even if it's a page route doesn't get generated in the manifest
-    // Ideally we would need to properly check api routes here
-    const isApiRoute = internalEvent.rawPath === apiPrefix ||
-        internalEvent.rawPath.startsWith(`${apiPrefix}/`);
-    const isNextImageRoute = internalEvent.rawPath.startsWith("/_next/image");
-    const isRouteFoundBeforeAllRewrites = isStaticRoute || isDynamicRoute || isExternalRewrite;
-    // If we still haven't found a route, we show the 404 page
-    // We need to ensure that rewrites are applied before showing the 404 page
-    if (!(isRouteFoundBeforeAllRewrites ||
-        isApiRoute ||
-        isNextImageRoute ||
-        // We need to check again once all rewrites have been applied
-        staticRouteMatcher(internalEvent.rawPath).length > 0 ||
-        dynamicRouteMatcher(internalEvent.rawPath).length > 0)) {
-        internalEvent = {
-            ...internalEvent,
-            rawPath: "/404",
-            url: constructNextUrl(internalEvent.url, "/404"),
-            headers: {
-                ...internalEvent.headers,
-                "x-middleware-response-cache-control": "private, no-cache, no-store, max-age=0, must-revalidate",
-            },
-        };
-    }
-    if (globalThis.openNextConfig.dangerous?.enableCacheInterception &&
-        !("statusCode" in internalEvent)) {
-        debug("Cache interception enabled");
-        internalEvent = await cacheInterceptor(internalEvent);
+        const nextHeaders = getNextConfigHeaders(event, ConfigHeaders);
+        let internalEvent = fixDataPage(event, BuildId);
         if ("statusCode" in internalEvent) {
-            applyMiddlewareHeaders(internalEvent.headers, {
-                ...middlewareResponseHeaders,
-                ...nextHeaders,
-            }, false);
             return internalEvent;
         }
+        const redirect = handleRedirects(internalEvent, RoutesManifest.redirects);
+        if (redirect) {
+            debug("redirect", redirect);
+            return redirect;
+        }
+        const eventOrResult = await handleMiddleware(internalEvent, 
+        // We need to pass the initial search without any decoding
+        // TODO: we'd need to refactor InternalEvent to include the initial querystring directly
+        // Should be done in another PR because it is a breaking change
+        new URL(event.url).search);
+        const isResult = "statusCode" in eventOrResult;
+        if (isResult) {
+            return eventOrResult;
+        }
+        const middlewareResponseHeaders = eventOrResult.responseHeaders;
+        let isExternalRewrite = eventOrResult.isExternalRewrite ?? false;
+        // internalEvent is `InternalEvent | MiddlewareEvent`
+        internalEvent = eventOrResult;
+        if (!isExternalRewrite) {
+            // First rewrite to be applied
+            const beforeRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.beforeFiles);
+            internalEvent = beforeRewrites.internalEvent;
+            isExternalRewrite = beforeRewrites.isExternalRewrite;
+        }
+        const foundStaticRoute = staticRouteMatcher(internalEvent.rawPath);
+        const isStaticRoute = !isExternalRewrite && foundStaticRoute.length > 0;
+        if (!(isStaticRoute || isExternalRewrite)) {
+            // Second rewrite to be applied
+            const afterRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.afterFiles);
+            internalEvent = afterRewrites.internalEvent;
+            isExternalRewrite = afterRewrites.isExternalRewrite;
+        }
+        // We want to run this just before the dynamic route check
+        const { event: fallbackEvent, isISR } = handleFallbackFalse(internalEvent, PrerenderManifest);
+        internalEvent = fallbackEvent;
+        const foundDynamicRoute = dynamicRouteMatcher(internalEvent.rawPath);
+        const isDynamicRoute = !isExternalRewrite && foundDynamicRoute.length > 0;
+        if (!(isDynamicRoute || isStaticRoute || isExternalRewrite)) {
+            // Fallback rewrite to be applied
+            const fallbackRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.fallback);
+            internalEvent = fallbackRewrites.internalEvent;
+            isExternalRewrite = fallbackRewrites.isExternalRewrite;
+        }
+        // Api routes are not present in the routes manifest except if they're not behind /api
+        // /api even if it's a page route doesn't get generated in the manifest
+        // Ideally we would need to properly check api routes here
+        const isApiRoute = internalEvent.rawPath === apiPrefix ||
+            internalEvent.rawPath.startsWith(`${apiPrefix}/`);
+        const isNextImageRoute = internalEvent.rawPath.startsWith("/_next/image");
+        const isRouteFoundBeforeAllRewrites = isStaticRoute || isDynamicRoute || isExternalRewrite;
+        // If we still haven't found a route, we show the 404 page
+        // We need to ensure that rewrites are applied before showing the 404 page
+        if (!(isRouteFoundBeforeAllRewrites ||
+            isApiRoute ||
+            isNextImageRoute ||
+            // We need to check again once all rewrites have been applied
+            staticRouteMatcher(internalEvent.rawPath).length > 0 ||
+            dynamicRouteMatcher(internalEvent.rawPath).length > 0)) {
+            internalEvent = {
+                ...internalEvent,
+                rawPath: "/404",
+                url: constructNextUrl(internalEvent.url, "/404"),
+                headers: {
+                    ...internalEvent.headers,
+                    "x-middleware-response-cache-control": "private, no-cache, no-store, max-age=0, must-revalidate",
+                },
+            };
+        }
+        if (globalThis.openNextConfig.dangerous?.enableCacheInterception &&
+            !("statusCode" in internalEvent)) {
+            debug("Cache interception enabled");
+            internalEvent = await cacheInterceptor(internalEvent);
+            if ("statusCode" in internalEvent) {
+                applyMiddlewareHeaders(internalEvent.headers, {
+                    ...middlewareResponseHeaders,
+                    ...nextHeaders,
+                }, false);
+                return internalEvent;
+            }
+        }
+        // We apply the headers from the middleware response last
+        applyMiddlewareHeaders(internalEvent.headers, {
+            ...middlewareResponseHeaders,
+            ...nextHeaders,
+        });
+        const resolvedRoutes = [
+            ...foundStaticRoute,
+            ...foundDynamicRoute,
+        ];
+        debug("resolvedRoutes", resolvedRoutes);
+        return {
+            internalEvent,
+            isExternalRewrite,
+            origin: false,
+            isISR,
+            resolvedRoutes,
+            initialURL: event.url,
+            locale: NextConfig.i18n
+                ? detectLocale(internalEvent, NextConfig.i18n)
+                : undefined,
+        };
+    }
+    catch (e) {
+        error("Error in routingHandler", e);
+        // In case of an error, we want to return the 500 page from Next.js
+        return {
+            internalEvent: {
+                type: "core",
+                method: "GET",
+                rawPath: "/500",
+                url: constructNextUrl(event.url, "/500"),
+                headers: {
+                    ...event.headers,
+                },
+                query: event.query,
+                cookies: event.cookies,
+                remoteAddress: event.remoteAddress,
+            },
+            isExternalRewrite: false,
+            origin: false,
+            isISR: false,
+            resolvedRoutes: [],
+            initialURL: event.url,
+            locale: NextConfig.i18n
+                ? detectLocale(event, NextConfig.i18n)
+                : undefined,
+        };
     }
-    // We apply the headers from the middleware response last
-    applyMiddlewareHeaders(internalEvent.headers, {
-        ...middlewareResponseHeaders,
-        ...nextHeaders,
-    });
-    const resolvedRoutes = [
-        ...foundStaticRoute,
-        ...foundDynamicRoute,
-    ];
-    debug("resolvedRoutes", resolvedRoutes);
-    return {
-        internalEvent,
-        isExternalRewrite,
-        origin: false,
-        isISR,
-        resolvedRoutes,
-        initialURL: event.url,
-        locale: NextConfig.i18n
-            ? detectLocale(internalEvent, NextConfig.i18n)
-            : undefined,
-    };
 }

package/dist/core/util.js

@@ -1,7 +1,7 @@
 import { AppPathsManifestKeys, NextConfig, RoutesManifest, } from "../adapters/config/index.js";
 // @ts-ignore
 import NextServer from "next/dist/server/next-server.js";
-import { debug } from "../adapters/logger.js";
+import { debug, error } from "../adapters/logger.js";
 import { applyOverride as applyNextjsRequireHooksOverride, overrideHooks as overrideNextjsRequireHooks, } from "./require-hooks.js";
 // WORKAROUND: Set `__NEXT_PRIVATE_PREBUNDLED_REACT` to use prebundled Reac
 // See https://opennext.js.org/aws/v2/advanced/workaround#workaround-set-__next_private_prebundled_react-to-use-prebundled-react
@@ -48,6 +48,46 @@ const nextServer = new NextServer.default({
     dev: false,
     dir: __dirname,
 });
+let routesLoaded = false;
+globalThis.__next_route_preloader = async (stage) => {
+    if (routesLoaded) {
+        return;
+    }
+    const thisFunction = globalThis.fnName
+        ? globalThis.openNextConfig.functions[globalThis.fnName]
+        : globalThis.openNextConfig.default;
+    const routePreloadingBehavior = thisFunction?.routePreloadingBehavior ?? "none";
+    if (routePreloadingBehavior === "none") {
+        routesLoaded = true;
+        return;
+    }
+    if (!("unstable_preloadEntries" in nextServer)) {
+        debug("The current version of Next.js does not support route preloading. Skipping route preloading.");
+        routesLoaded = true;
+        return;
+    }
+    if (stage === "waitUntil" && routePreloadingBehavior === "withWaitUntil") {
+        // We need to access the waitUntil
+        const waitUntil = globalThis.__openNextAls.getStore()?.waitUntil;
+        if (!waitUntil) {
+            error("You've tried to use the 'withWaitUntil' route preloading behavior, but the 'waitUntil' function is not available.");
+            routesLoaded = true;
+            return;
+        }
+        debug("Preloading entries with waitUntil");
+        waitUntil?.(nextServer.unstable_preloadEntries());
+        routesLoaded = true;
+    }
+    else if ((stage === "start" && routePreloadingBehavior === "onStart") ||
+        (stage === "warmerEvent" && routePreloadingBehavior === "onWarmerEvent") ||
+        stage === "onDemand") {
+        const startTimestamp = Date.now();
+        debug("Preloading entries");
+        await nextServer.unstable_preloadEntries();
+        debug("Preloading entries took", Date.now() - startTimestamp, "ms");
+        routesLoaded = true;
+    }
+};
 // `getRequestHandlerWithMetadata` is not available in older versions of Next.js
 // It is required to for next 15.2 to pass metadata for page router data route
 export const requestHandler = (metadata) => "getRequestHandlerWithMetadata" in nextServer

package/dist/http/util.d.ts

@@ -2,3 +2,10 @@ 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[] | null | undefined): string[];
+/**
+ *
+ * Get the query object from an iterable of [key, value] pairs
+ * @param it - The iterable of [key, value] pairs
+ * @returns The query object
+ */
+export declare function getQueryFromIterator(it: Iterable<[string, string]>): Record<string, string | string[]>;

package/dist/http/util.js

@@ -28,3 +28,26 @@ export function parseCookies(cookies) {
         ? cookies.split(/(?<!Expires=\w+),/i).map((c) => c.trim())
         : cookies;
 }
+/**
+ *
+ * Get the query object from an iterable of [key, value] pairs
+ * @param it - The iterable of [key, value] pairs
+ * @returns The query object
+ */
+export function getQueryFromIterator(it) {
+    const query = {};
+    for (const [key, value] of it) {
+        if (key in query) {
+            if (Array.isArray(query[key])) {
+                query[key].push(value);
+            }
+            else {
+                query[key] = [query[key], value];
+            }
+        }
+        else {
+            query[key] = value;
+        }
+    }
+    return query;
+}

package/dist/overrides/converters/edge.js

@@ -1,23 +1,11 @@
 import { Buffer } from "node:buffer";
 import { parseCookies } from "../../http/util";
+import { getQueryFromSearchParams } from "./utils.js";
 const converter = {
     convertFrom: async (event) => {
         const url = new URL(event.url);
         const searchParams = url.searchParams;
-        const query = {};
-        for (const [key, value] of searchParams.entries()) {
-            if (key in query) {
-                if (Array.isArray(query[key])) {
-                    query[key].push(value);
-                }
-                else {
-                    query[key] = [query[key], value];
-                }
-            }
-            else {
-                query[key] = value;
-            }
-        }
+        const query = getQueryFromSearchParams(searchParams);
         // Transform body into Buffer
         const body = await event.arrayBuffer();
         const headers = {};

package/dist/overrides/converters/node.js

@@ -1,5 +1,5 @@
 import { parseCookies } from "../../http/util";
-import { extractHostFromHeaders } from "./utils";
+import { extractHostFromHeaders, getQueryFromSearchParams } from "./utils.js";
 const converter = {
     convertFrom: async (req) => {
         const body = await new Promise((resolve) => {
@@ -18,7 +18,7 @@ const converter = {
         ])
             .filter(([key]) => key));
         const url = new URL(req.url, `http://${extractHostFromHeaders(headers)}`);
-        const query = Object.fromEntries(url.searchParams.entries());
+        const query = getQueryFromSearchParams(url.searchParams);
         return {
             type: "core",
             method: req.method ?? "GET",

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

@@ -6,3 +6,10 @@ export declare function removeUndefinedFromQuery(query: Record<string, string |
  * @returns The host
  */
 export declare function extractHostFromHeaders(headers: Record<string, string>): string;
+/**
+ * Get the query object from an URLSearchParams
+ *
+ * @param searchParams
+ * @returns
+ */
+export declare function getQueryFromSearchParams(searchParams: URLSearchParams): Record<string, string | string[]>;

package/dist/overrides/converters/utils.js

@@ -1,3 +1,4 @@
+import { getQueryFromIterator } from "../../http/util.js";
 export function removeUndefinedFromQuery(query) {
     const newQuery = {};
     for (const [key, value] of Object.entries(query)) {
@@ -16,3 +17,12 @@ export function removeUndefinedFromQuery(query) {
 export function extractHostFromHeaders(headers) {
     return headers["x-forwarded-host"] ?? headers.host ?? "on";
 }
+/**
+ * Get the query object from an URLSearchParams
+ *
+ * @param searchParams
+ * @returns
+ */
+export function getQueryFromSearchParams(searchParams) {
+    return getQueryFromIterator(searchParams.entries());
+}

package/dist/overrides/wrappers/aws-lambda-compressed.d.ts

@@ -0,0 +1,7 @@
+import type { WrapperHandler } from "../../types/overrides";
+declare const _default: {
+    wrapper: WrapperHandler;
+    name: string;
+    supportStreaming: boolean;
+};
+export default _default;

package/dist/overrides/wrappers/aws-lambda-compressed.js

@@ -0,0 +1,96 @@
+import { Readable, Writable } from "node:stream";
+import zlib from "node:zlib";
+import { error } from "../../adapters/logger";
+import { formatWarmerResponse } from "./aws-lambda";
+const handler = async (handler, converter) => async (event) => {
+    // Handle warmer event
+    if ("type" in event) {
+        return formatWarmerResponse(event);
+    }
+    const internalEvent = await converter.convertFrom(event);
+    // This is a workaround
+    // https://github.com/opennextjs/opennextjs-aws/blob/e9b37fd44eb856eb8ae73168bf455ff85dd8b285/packages/open-next/src/overrides/wrappers/aws-lambda.ts#L49-L53
+    const fakeStream = {
+        writeHeaders: () => {
+            return new Writable({
+                write: (_chunk, _encoding, callback) => {
+                    callback();
+                },
+            });
+        },
+    };
+    const handlerResponse = await handler(internalEvent, {
+        streamCreator: fakeStream,
+    });
+    // Check if response is already compressed
+    // The handlers response headers are lowercase
+    const alreadyEncoded = handlerResponse.headers["content-encoding"] ?? "";
+    // Return early here if the response is already compressed
+    if (alreadyEncoded) {
+        return converter.convertTo(handlerResponse, event);
+    }
+    // We compress the body if the client accepts it
+    const acceptEncoding = internalEvent.headers["accept-encoding"] ??
+        internalEvent.headers["Accept-Encoding"] ??
+        "";
+    let contentEncoding = null;
+    if (acceptEncoding?.includes("br")) {
+        contentEncoding = "br";
+    }
+    else if (acceptEncoding?.includes("gzip")) {
+        contentEncoding = "gzip";
+    }
+    else if (acceptEncoding?.includes("deflate")) {
+        contentEncoding = "deflate";
+    }
+    const response = {
+        ...handlerResponse,
+        body: compressBody(handlerResponse.body, contentEncoding),
+        headers: {
+            ...handlerResponse.headers,
+            ...(contentEncoding ? { "content-encoding": contentEncoding } : {}),
+        },
+        isBase64Encoded: !!contentEncoding || handlerResponse.isBase64Encoded,
+    };
+    return converter.convertTo(response, event);
+};
+export default {
+    wrapper: handler,
+    name: "aws-lambda-compressed",
+    supportStreaming: false,
+};
+function compressBody(body, encoding) {
+    // If no encoding is specified, return original body
+    if (!encoding)
+        return body;
+    try {
+        const readable = Readable.fromWeb(body);
+        let transform;
+        switch (encoding) {
+            case "br":
+                transform = zlib.createBrotliCompress({
+                    params: {
+                        // This is a compromise between speed and compression ratio.
+                        // The default one will most likely timeout an AWS Lambda with default configuration on large bodies (>6mb).
+                        // Therefore we set it to 6, which is a good compromise.
+                        [zlib.constants.BROTLI_PARAM_QUALITY]: Number(process.env.BROTLI_QUALITY) ?? 6,
+                    },
+                });
+                break;
+            case "gzip":
+                transform = zlib.createGzip();
+                break;
+            case "deflate":
+                transform = zlib.createDeflate();
+                break;
+            default:
+                return body;
+        }
+        return Readable.toWeb(readable.pipe(transform));
+    }
+    catch (e) {
+        error("Error compressing body:", e);
+        // Fall back to no compression on error
+        return body;
+    }
+}

package/dist/overrides/wrappers/aws-lambda-streaming.js

@@ -14,6 +14,7 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
     if ("type" in event) {
         const result = await formatWarmerResponse(event);
         responseStream.end(Buffer.from(JSON.stringify(result)), "utf-8");
+        await globalThis.__next_route_preloader("warmerEvent");
         return;
     }
     const internalEvent = await converter.convertFrom(event);

package/dist/overrides/wrappers/aws-lambda.d.ts

@@ -1,4 +1,6 @@
 import type { WrapperHandler } from "../../types/overrides";
+import type { WarmerEvent, WarmerResponse } from "../../adapters/warmer-function";
+export declare function formatWarmerResponse(event: WarmerEvent): Promise<WarmerResponse>;
 declare const _default: {
     wrapper: WrapperHandler;
     name: string;

package/dist/overrides/wrappers/aws-lambda.js

@@ -1,5 +1,5 @@
 import { Writable } from "node:stream";
-function formatWarmerResponse(event) {
+export function formatWarmerResponse(event) {
     return new Promise((resolve) => {
         setTimeout(() => {
             resolve({ serverId, type: "warmer" });

package/dist/types/aws-lambda.d.ts

@@ -1,5 +1,6 @@
 import type { Writable } from "node:stream";
-import type { APIGatewayProxyEventV2, Context } from "aws-lambda";
+import type { APIGatewayProxyEvent, APIGatewayProxyEventV2, APIGatewayProxyResult, APIGatewayProxyResultV2, CloudFrontRequestEvent, CloudFrontRequestResult, Context } from "aws-lambda";
+import type { WarmerEvent, WarmerResponse } from "../adapters/warmer-function";
 export interface ResponseStream extends Writable {
     getBufferedData(): Buffer;
     setContentType(contentType: string): void;
@@ -17,4 +18,6 @@ declare global {
         }
     }
 }
+export type AwsLambdaEvent = APIGatewayProxyEventV2 | CloudFrontRequestEvent | APIGatewayProxyEvent | WarmerEvent;
+export type AwsLambdaReturn = APIGatewayProxyResultV2 | APIGatewayProxyResult | CloudFrontRequestResult | WarmerResponse;
 export {};

package/dist/types/global.d.ts

@@ -179,5 +179,11 @@ declare global {
      * Defined in `createMainHandler`
      */
     var cdnInvalidationHandler: CDNInvalidationHandler;
+    /**
+     * A function to preload the routes.
+     * This needs to be defined on globalThis because it can be used by custom overrides.
+     * Only available in main functions.
+     */
+    var __next_route_preloader: (stage: "waitUntil" | "start" | "warmerEvent" | "onDemand") => Promise<void>;
 }
 export {};

package/dist/types/open-next.d.ts

@@ -67,13 +67,23 @@ export interface Origin {
     port?: number;
     customHeaders?: Record<string, string>;
 }
-export type IncludedWrapper = "aws-lambda" | "aws-lambda-streaming" | "node" | "cloudflare" | "cloudflare-edge" | "cloudflare-node" | "express-dev" | "dummy";
+export type IncludedWrapper = "aws-lambda" | "aws-lambda-streaming" | "aws-lambda-compressed" | "node" | "cloudflare" | "cloudflare-edge" | "cloudflare-node" | "express-dev" | "dummy";
 export type IncludedConverter = "aws-apigw-v2" | "aws-apigw-v1" | "aws-cloudfront" | "edge" | "node" | "sqs-revalidate" | "dummy";
 export type RouteType = "route" | "page" | "app";
 export interface ResolvedRoute {
     route: string;
     type: RouteType;
 }
+/**
+ * The route preloading behavior. Only supported in Next 15+.
+ * Default behavior of Next is disabled. You should do your own testing to choose which one suits you best
+ * - "none" - No preloading of the route at all. This is the default
+ * - "withWaitUntil" - Preload the route using the waitUntil provided by the wrapper - If not supported, it will fallback to "none". At the moment only cloudflare wrappers provide a `waitUntil`
+ * - "onWarmerEvent" - Preload the route on the warmer event - Needs to be implemented by the wrapper. Only supported in `aws-lambda-streaming` wrapper for now
+ * - "onStart" - Preload the route before even invoking the wrapper - This is a blocking operation. The handler will only be created after all the routes have been loaded, it may increase the cold start time by a lot in some cases. Useful for long running server or in serverless with some careful testing
+ * @default "none"
+ */
+export type RoutePreloadingBehavior = "none" | "withWaitUntil" | "onWarmerEvent" | "onStart";
 export interface RoutingResult {
     internalEvent: InternalEvent;
     isExternalRewrite: boolean;
@@ -212,6 +222,7 @@ export interface FunctionOptions extends DefaultFunctionOptions {
      * @deprecated This is not supported in 14.2+
      */
     experimentalBundledNextServer?: boolean;
+    routePreloadingBehavior?: RoutePreloadingBehavior;
 }
 export type RouteTemplate = `app/${string}/route` | `app/${string}/page` | `app/page` | `app/route` | `pages/${string}`;
 export interface SplittedFunctionOptions extends FunctionOptions {

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.5.4",
+  "version": "3.5.6",
   "bin": {
     "open-next": "./dist/index.js"
   },