@opennextjs/aws 3.2.1 → 3.2.2

package/dist/core/createMainHandler.js

@@ -1,10 +1,10 @@
 import { debug } from "../adapters/logger";
 import { generateUniqueId } from "../adapters/util";
-import { openNextHandler } from "./requestHandler.js";
-import { resolveConverter, resolveIncrementalCache, resolveQueue, resolveTagCache, resolveWrapper, } from "./resolve";
+import { openNextHandler } from "./requestHandler";
+import { resolveConverter, resolveIncrementalCache, resolveProxyRequest, resolveQueue, resolveTagCache, resolveWrapper, } from "./resolve";
 export async function createMainHandler() {
-    //First we load the config
-    const config = await import(process.cwd() + "/open-next.config.mjs").then((m) => m.default);
+    // @ts-expect-error `./open-next.config.mjs` exists only in the build output
+    const config = await import("./open-next.config.mjs").then((m) => m.default);
     const thisFunction = globalThis.fnName
         ? config.functions[globalThis.fnName]
         : config.default;
@@ -14,6 +14,7 @@ export async function createMainHandler() {
     globalThis.queue = await resolveQueue(thisFunction.override?.queue);
     globalThis.incrementalCache = await resolveIncrementalCache(thisFunction.override?.incrementalCache);
     globalThis.tagCache = await resolveTagCache(thisFunction.override?.tagCache);
+    globalThis.proxyExternalRequest = await resolveProxyRequest(thisFunction.override?.proxyExternalRequest);
     globalThis.lastModified = {};
     // From the config, we create the converter
     const converter = await resolveConverter(thisFunction.override?.converter);

package/dist/core/edgeFunctionHandler.d.ts

@@ -1,54 +1,4 @@
-/// <reference types="node" />
-import type { OutgoingHttpHeaders } from "http";
-interface RequestData {
-    geo?: {
-        city?: string;
-        country?: string;
-        region?: string;
-        latitude?: string;
-        longitude?: string;
-    };
-    headers: OutgoingHttpHeaders;
-    ip?: string;
-    method: string;
-    nextConfig?: {
-        basePath?: string;
-        i18n?: any;
-        trailingSlash?: boolean;
-    };
-    page?: {
-        name?: string;
-        params?: {
-            [key: string]: string | string[];
-        };
-    };
-    url: string;
-    body?: ReadableStream<Uint8Array>;
-    signal: AbortSignal;
-}
-interface Entries {
-    [k: string]: {
-        default: (props: {
-            page: string;
-            request: RequestData;
-        }) => Promise<{
-            response: Response;
-            waitUntil: Promise<void>;
-        }>;
-    };
-}
-declare global {
-    var _ENTRIES: Entries;
-    var _ROUTES: EdgeRoute[];
-    var __storage__: Map<unknown, unknown>;
-    var AsyncContext: any;
-    var AsyncLocalStorage: any;
-}
-export interface EdgeRoute {
-    name: string;
-    page: string;
-    regex: string[];
-}
+import type { RequestData } from "../types/global";
 type EdgeRequest = Omit<RequestData, "page">;
 export default function edgeFunctionHandler(request: EdgeRequest): Promise<Response>;
 export {};

package/dist/core/patchAsyncStorage.js

@@ -1,16 +1,15 @@
-const mod = require("module");
+const mod = require("node:module");
 const resolveFilename = mod._resolveFilename;
 export function patchAsyncStorage() {
-    mod._resolveFilename = function (originalResolveFilename, request, parent, isMain, options) {
+    mod._resolveFilename = ((originalResolveFilename, request, parent, isMain, options) => {
         if (request.endsWith("static-generation-async-storage.external") ||
             request.endsWith("static-generation-async-storage.external.js")) {
             return require.resolve("./patchedAsyncStorage.cjs");
         }
-        else if (request.endsWith("static-generation-async-storage.external.original")) {
+        if (request.endsWith("static-generation-async-storage.external.original")) {
             return originalResolveFilename.call(mod, request.replace(".original", ".js"), parent, isMain, options);
         }
-        else
-            return originalResolveFilename.call(mod, request, parent, isMain, options);
+        return originalResolveFilename.call(mod, request, parent, isMain, options);
         // We use `bind` here to avoid referencing outside variables to create potential memory leaks.
-    }.bind(null, resolveFilename);
+    }).bind(null, resolveFilename);
 }

package/dist/core/requestHandler.js

@@ -1,65 +1,88 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { IncomingMessage } from "../http/index.js";
-import { DetachedPromiseRunner } from "../utils/promise";
+import { runWithOpenNextRequestContext } from "../utils/promise";
 import { debug, error, warn } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
-import { convertRes, createServerResponse, proxyRequest } from "./routing/util";
-import routingHandler from "./routingHandler";
+import { convertRes, createServerResponse } from "./routing/util";
+import routingHandler, { MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
 import { requestHandler, setNextjsPrebundledReact } from "./util";
 // This is used to identify requests in the cache
-globalThis.__als = new AsyncLocalStorage();
+globalThis.__openNextAls = new AsyncLocalStorage();
 patchAsyncStorage();
 export async function openNextHandler(internalEvent, responseStreaming) {
-    if (internalEvent.headers["x-forwarded-host"]) {
-        internalEvent.headers.host = internalEvent.headers["x-forwarded-host"];
-    }
-    debug("internalEvent", internalEvent);
-    let preprocessResult = {
-        internalEvent: internalEvent,
-        isExternalRewrite: false,
-        origin: false,
-        isISR: false,
-    };
-    //#override withRouting
-    try {
-        preprocessResult = await routingHandler(internalEvent);
-    }
-    catch (e) {
-        warn("Routing failed.", e);
-    }
-    //#endOverride
-    const headers = "type" in preprocessResult
-        ? preprocessResult.headers
-        : preprocessResult.internalEvent.headers;
-    const overwrittenResponseHeaders = Object.entries("type" in preprocessResult
-        ? preprocessResult.headers
-        : preprocessResult.internalEvent.headers).reduce((acc, [key, value]) => {
-        if (!key.startsWith("x-middleware-response-")) {
-            return acc;
+    // We run everything in the async local storage context so that it is available in the middleware as well as in NextServer
+    return runWithOpenNextRequestContext({ isISRRevalidation: internalEvent.headers["x-isr"] === "1" }, async () => {
+        if (internalEvent.headers["x-forwarded-host"]) {
+            internalEvent.headers.host = internalEvent.headers["x-forwarded-host"];
         }
-        else {
-            const newKey = key.replace("x-middleware-response-", "");
-            delete headers[key];
-            headers[newKey] = value;
-            return { ...acc, [newKey]: value };
+        debug("internalEvent", internalEvent);
+        let preprocessResult = {
+            internalEvent: internalEvent,
+            isExternalRewrite: false,
+            origin: false,
+            isISR: false,
+        };
+        //#override withRouting
+        try {
+            preprocessResult = await routingHandler(internalEvent);
+        }
+        catch (e) {
+            warn("Routing failed.", e);
         }
-    }, {});
-    if ("type" in preprocessResult) {
-        // // res is used only in the streaming case
-        if (responseStreaming) {
-            const res = createServerResponse(internalEvent, headers, responseStreaming);
-            res.statusCode = preprocessResult.statusCode;
-            res.flushHeaders();
-            const [bodyToConsume, bodyToReturn] = preprocessResult.body.tee();
-            for await (const chunk of bodyToConsume) {
-                res.write(chunk);
+        //#endOverride
+        const headers = "type" in preprocessResult
+            ? preprocessResult.headers
+            : preprocessResult.internalEvent.headers;
+        const overwrittenResponseHeaders = {};
+        for (const [rawKey, value] of Object.entries(headers)) {
+            if (!rawKey.startsWith(MIDDLEWARE_HEADER_PREFIX)) {
+                continue;
             }
-            res.end();
-            preprocessResult.body = bodyToReturn;
+            const key = rawKey.slice(MIDDLEWARE_HEADER_PREFIX_LEN);
+            overwrittenResponseHeaders[key] = value;
+            headers[key] = value;
+            delete headers[rawKey];
+        }
+        if ("isExternalRewrite" in preprocessResult &&
+            preprocessResult.isExternalRewrite === true) {
+            try {
+                preprocessResult = await globalThis.proxyExternalRequest.proxy(preprocessResult.internalEvent);
+            }
+            catch (e) {
+                error("External request failed.", e);
+                preprocessResult = {
+                    internalEvent: {
+                        type: "core",
+                        rawPath: "/500",
+                        method: "GET",
+                        headers: {},
+                        url: "/500",
+                        query: {},
+                        cookies: {},
+                        remoteAddress: "",
+                    },
+                    // On error we need to rewrite to the 500 page which is an internal rewrite
+                    isExternalRewrite: false,
+                    isISR: false,
+                    origin: false,
+                };
+            }
+        }
+        if ("type" in preprocessResult) {
+            // response is used only in the streaming case
+            if (responseStreaming) {
+                const response = createServerResponse(internalEvent, headers, responseStreaming);
+                response.statusCode = preprocessResult.statusCode;
+                response.flushHeaders();
+                const [bodyToConsume, bodyToReturn] = preprocessResult.body.tee();
+                for await (const chunk of bodyToConsume) {
+                    response.write(chunk);
+                }
+                response.end();
+                preprocessResult.body = bodyToReturn;
+            }
+            return preprocessResult;
         }
-        return preprocessResult;
-    }
-    else {
         const preprocessedEvent = preprocessResult.internalEvent;
         debug("preprocessedEvent", preprocessedEvent);
         const reqProps = {
@@ -74,58 +97,44 @@ export async function openNextHandler(internalEvent, responseStreaming) {
             body: preprocessedEvent.body,
             remoteAddress: preprocessedEvent.remoteAddress,
         };
-        const requestId = Math.random().toString(36);
-        const pendingPromiseRunner = new DetachedPromiseRunner();
-        const isISRRevalidation = headers["x-isr"] === "1";
         const mergeHeadersPriority = globalThis.openNextConfig.dangerous
             ?.headersAndCookiesPriority
             ? globalThis.openNextConfig.dangerous.headersAndCookiesPriority(preprocessedEvent)
             : "middleware";
-        const internalResult = await globalThis.__als.run({
-            requestId,
-            pendingPromiseRunner,
-            isISRRevalidation,
-            mergeHeadersPriority,
-        }, async () => {
-            const preprocessedResult = preprocessResult;
-            const req = new IncomingMessage(reqProps);
-            const res = createServerResponse(preprocessedEvent, overwrittenResponseHeaders, responseStreaming);
-            await processRequest(req, res, preprocessedEvent, preprocessedResult.isExternalRewrite);
-            const { statusCode, headers, isBase64Encoded, body } = convertRes(res);
-            const internalResult = {
-                type: internalEvent.type,
-                statusCode,
-                headers,
-                body,
-                isBase64Encoded,
-            };
+        const store = globalThis.__openNextAls.getStore();
+        if (store) {
+            store.mergeHeadersPriority = mergeHeadersPriority;
+        }
+        const req = new IncomingMessage(reqProps);
+        const res = createServerResponse(preprocessedEvent, overwrittenResponseHeaders, responseStreaming);
+        await processRequest(req, res, preprocessedEvent);
+        const { statusCode, headers: responseHeaders, isBase64Encoded, body, } = convertRes(res);
+        const internalResult = {
+            type: internalEvent.type,
+            statusCode,
+            headers: responseHeaders,
+            body,
+            isBase64Encoded,
+        };
+        const requestId = store?.requestId;
+        if (requestId) {
             // reset lastModified. We need to do this to avoid memory leaks
             delete globalThis.lastModified[requestId];
-            await pendingPromiseRunner.await();
-            return internalResult;
-        });
+        }
         return internalResult;
-    }
+    });
 }
-async function processRequest(req, res, internalEvent, isExternalRewrite) {
+async function processRequest(req, res, internalEvent) {
     // @ts-ignore
     // Next.js doesn't parse body if the property exists
     // https://github.com/dougmoscrop/serverless-http/issues/227
     delete req.body;
     try {
-        // `serverHandler` is replaced at build time depending on user's
-        // nextjs version to patch Nextjs 13.4.x and future breaking changes.
-        const { rawPath } = internalEvent;
-        if (isExternalRewrite) {
-            return proxyRequest(internalEvent, res);
-        }
-        else {
-            //#override applyNextjsPrebundledReact
-            setNextjsPrebundledReact(rawPath);
-            //#endOverride
-            // Next Server
-            await requestHandler(req, res);
-        }
+        //#override applyNextjsPrebundledReact
+        setNextjsPrebundledReact(internalEvent.rawPath);
+        //#endOverride
+        // Next Server
+        await requestHandler(req, res);
     }
     catch (e) {
         // This might fail when using bundled next, importing won't do the trick either

package/dist/core/require-hooks.js

@@ -3,7 +3,7 @@
 // Individually compiled modules are as defined for the compilation in bundles/webpack/packages/*.
 import { error } from "../adapters/logger.js";
 // This module will only be loaded once per process.
-const mod = require("module");
+const mod = require("node:module");
 const resolveFilename = mod._resolveFilename;
 const hookPropertyMapApp = new Map();
 const hookPropertyMapPage = new Map();
@@ -17,7 +17,7 @@ export function overrideHooks(config) {
         throw e;
     }
 }
-function addHookAliases(aliases = [], type) {
+function addHookAliases(aliases, type) {
     for (const [key, value] of aliases) {
         type === "app"
             ? hookPropertyMapApp.set(key, value)
@@ -68,12 +68,12 @@ function overrideDefault() {
 const toResolveMap = (map) => Object.entries(map).map(([key, value]) => [key, require.resolve(value)]);
 // Override built-in React packages if necessary
 function overrideReact(config) {
-    addHookAliases([["react", require.resolve(`react`)]], "page");
+    addHookAliases([["react", require.resolve("react")]], "page");
     // ignore: react/jsx-dev-runtime is not available on older version of Next.js ie. v13.1.6
     // react/jsx-runtime is not available on newer version of Next.js ie. v13.4.10-canary.3
     try {
-        addHookAliases([["react/jsx-runtime", require.resolve(`react/jsx-runtime`)]], "page");
-        addHookAliases([["react/jsx-dev-runtime", require.resolve(`react/jsx-dev-runtime`)]], "page");
+        addHookAliases([["react/jsx-runtime", require.resolve("react/jsx-runtime")]], "page");
+        addHookAliases([["react/jsx-dev-runtime", require.resolve("react/jsx-dev-runtime")]], "page");
     }
     catch (e) { }
     if (config.experimental.appDir) {
@@ -90,13 +90,14 @@ function isApp() {
         process.env.__NEXT_PRIVATE_PREBUNDLED_REACT === "experimental");
 }
 export function applyOverride() {
-    mod._resolveFilename = function (originalResolveFilename, requestMapApp, requestMapPage, request, parent, isMain, options) {
+    mod._resolveFilename = ((originalResolveFilename, requestMapApp, requestMapPage, request, parent, isMain, options) => {
         const hookResolved = isApp()
             ? requestMapApp.get(request)
             : requestMapPage.get(request);
+        // biome-ignore lint/style/noParameterAssign:
         if (hookResolved)
             request = hookResolved;
         return originalResolveFilename.call(mod, request, parent, isMain, options);
         // We use `bind` here to avoid referencing outside variables to create potential memory leaks.
-    }.bind(null, resolveFilename, hookPropertyMapApp, hookPropertyMapPage);
+    }).bind(null, resolveFilename, hookPropertyMapApp, hookPropertyMapPage);
 }

package/dist/core/resolve.d.ts

@@ -1,5 +1,6 @@
-import type { BaseEventOrResult, Converter, DefaultOverrideOptions, ImageLoader, InternalEvent, InternalResult, LazyLoadedOverride, OriginResolver, OverrideOptions, Warmer, Wrapper } from "../types/open-next.js";
-import type { TagCache } from "../overrides/tagCache/types.js";
+import type { BaseEventOrResult, DefaultOverrideOptions, InternalEvent, InternalResult, OpenNextConfig, OverrideOptions } from "../types/open-next";
+import type { Converter, TagCache, Wrapper } from "../types/overrides";
+type RemoveUndefined<T> = T extends undefined ? never : T;
 export declare function resolveConverter<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult>(converter: DefaultOverrideOptions<E, R>["converter"]): Promise<Converter<E, R>>;
 export declare function resolveWrapper<E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult>(wrapper: DefaultOverrideOptions<E, R>["wrapper"]): Promise<Wrapper<E, R>>;
 /**
@@ -15,26 +16,31 @@ export declare function resolveTagCache(tagCache: OverrideOptions["tagCache"]):
  * @returns
  * @__PURE__
  */
-export declare function resolveQueue(queue: OverrideOptions["queue"]): Promise<import("../overrides/queue/types.js").Queue>;
+export declare function resolveQueue(queue: OverrideOptions["queue"]): Promise<import("../types/overrides").Queue>;
 /**
  *
  * @param incrementalCache
  * @returns
  * @__PURE__
  */
-export declare function resolveIncrementalCache(incrementalCache: OverrideOptions["incrementalCache"]): Promise<import("../overrides/incrementalCache/types.js").IncrementalCache>;
+export declare function resolveIncrementalCache(incrementalCache: OverrideOptions["incrementalCache"]): Promise<import("../types/overrides").IncrementalCache>;
 /**
  * @param imageLoader
  * @returns
  * @__PURE__
  */
-export declare function resolveImageLoader(imageLoader: LazyLoadedOverride<ImageLoader> | string): Promise<ImageLoader>;
+export declare function resolveImageLoader(imageLoader: RemoveUndefined<OpenNextConfig["imageOptimization"]>["loader"]): Promise<import("../types/overrides").ImageLoader>;
 /**
  * @returns
  * @__PURE__
  */
-export declare function resolveOriginResolver(originResolver?: LazyLoadedOverride<OriginResolver> | string): Promise<OriginResolver>;
+export declare function resolveOriginResolver(originResolver: RemoveUndefined<OpenNextConfig["middleware"]>["originResolver"]): Promise<import("../types/overrides").OriginResolver>;
 /**
  * @__PURE__
  */
-export declare function resolveWarmerInvoke(warmer?: LazyLoadedOverride<Warmer> | "aws-lambda"): Promise<Warmer>;
+export declare function resolveWarmerInvoke(warmer: RemoveUndefined<OpenNextConfig["warmer"]>["invokeFunction"]): Promise<import("../types/overrides").Warmer>;
+/**
+ * @__PURE__
+ */
+export declare function resolveProxyRequest(proxyRequest: OverrideOptions["proxyExternalRequest"]): Promise<import("../types/overrides").ProxyExternalRequest>;
+export {};

package/dist/core/resolve.js

@@ -2,22 +2,18 @@ export async function resolveConverter(converter) {
     if (typeof converter === "function") {
         return converter();
     }
-    else {
-        const m_1 = await import(`../overrides/converters/aws-apigw-v2.js`);
-        // @ts-expect-error
-        return m_1.default;
-    }
+    const m_1 = await import("../overrides/converters/aws-apigw-v2.js");
+    // @ts-expect-error
+    return m_1.default;
 }
 export async function resolveWrapper(wrapper) {
     if (typeof wrapper === "function") {
         return wrapper();
     }
-    else {
-        // This will be replaced by the bundler
-        const m_1 = await import("../overrides/wrappers/aws-lambda.js");
-        // @ts-expect-error
-        return m_1.default;
-    }
+    // This will be replaced by the bundler
+    const m_1 = await import("../overrides/wrappers/aws-lambda.js");
+    // @ts-expect-error
+    return m_1.default;
 }
 /**
  *
@@ -29,11 +25,9 @@ export async function resolveTagCache(tagCache) {
     if (typeof tagCache === "function") {
         return tagCache();
     }
-    else {
-        // This will be replaced by the bundler
-        const m_1 = await import("../overrides/tagCache/dynamodb.js");
-        return m_1.default;
-    }
+    // This will be replaced by the bundler
+    const m_1 = await import("../overrides/tagCache/dynamodb.js");
+    return m_1.default;
 }
 /**
  *
@@ -45,10 +39,8 @@ export async function resolveQueue(queue) {
     if (typeof queue === "function") {
         return queue();
     }
-    else {
-        const m_1 = await import("../overrides/queue/sqs.js");
-        return m_1.default;
-    }
+    const m_1 = await import("../overrides/queue/sqs.js");
+    return m_1.default;
 }
 /**
  *
@@ -60,10 +52,8 @@ export async function resolveIncrementalCache(incrementalCache) {
     if (typeof incrementalCache === "function") {
         return incrementalCache();
     }
-    else {
-        const m_1 = await import("../overrides/incrementalCache/s3.js");
-        return m_1.default;
-    }
+    const m_1 = await import("../overrides/incrementalCache/s3.js");
+    return m_1.default;
 }
 /**
  * @param imageLoader
@@ -74,10 +64,8 @@ export async function resolveImageLoader(imageLoader) {
     if (typeof imageLoader === "function") {
         return imageLoader();
     }
-    else {
-        const m_1 = await import("../overrides/imageLoader/s3.js");
-        return m_1.default;
-    }
+    const m_1 = await import("../overrides/imageLoader/s3.js");
+    return m_1.default;
 }
 /**
  * @returns
@@ -87,10 +75,8 @@ 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;
-    }
+    const m_1 = await import("../overrides/originResolver/pattern-env.js");
+    return m_1.default;
 }
 /**
  * @__PURE__
@@ -99,8 +85,16 @@ 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;
+    const m_1 = await import("../overrides/warmer/aws-lambda.js");
+    return m_1.default;
+}
+/**
+ * @__PURE__
+ */
+export async function resolveProxyRequest(proxyRequest) {
+    if (typeof proxyRequest === "function") {
+        return proxyRequest();
     }
+    const m_1 = await import("../overrides/proxyExternalRequest/node.js");
+    return m_1.default;
 }

package/dist/core/routing/cacheInterceptor.js

@@ -31,7 +31,7 @@ async function computeCacheControl(path, body, host, revalidate, lastModified) {
             etag,
         };
     }
-    else if (finalRevalidate !== CACHE_ONE_YEAR) {
+    if (finalRevalidate !== CACHE_ONE_YEAR) {
         const sMaxAge = Math.max(finalRevalidate - age, 1);
         debug("sMaxAge", {
             finalRevalidate,
@@ -58,13 +58,11 @@ async function computeCacheControl(path, body, host, revalidate, lastModified) {
             etag,
         };
     }
-    else {
-        return {
-            "cache-control": `s-maxage=${CACHE_ONE_YEAR}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
-            "x-opennext-cache": "HIT",
-            etag,
-        };
-    }
+    return {
+        "cache-control": `s-maxage=${CACHE_ONE_YEAR}, stale-while-revalidate=${CACHE_ONE_MONTH}`,
+        "x-opennext-cache": "HIT",
+        etag,
+    };
 }
 async function generateResult(event, localizedPath, cachedValue, lastModified) {
     debug("Returning result from experimental cache");
@@ -73,19 +71,19 @@ async function generateResult(event, localizedPath, cachedValue, lastModified) {
     let isDataRequest = false;
     switch (cachedValue.type) {
         case "app":
-            isDataRequest = Boolean(event.headers["rsc"]);
+            isDataRequest = Boolean(event.headers.rsc);
             body = isDataRequest ? cachedValue.rsc : cachedValue.html;
             type = isDataRequest ? "text/x-component" : "text/html; charset=utf-8";
             break;
         case "page":
-            isDataRequest = Boolean(event.query["__nextDataReq"]);
+            isDataRequest = Boolean(event.query.__nextDataReq);
             body = isDataRequest
                 ? JSON.stringify(cachedValue.json)
                 : cachedValue.html;
             type = isDataRequest ? "application/json" : "text/html; charset=utf-8";
             break;
     }
-    const cacheControl = await computeCacheControl(localizedPath, body, event.headers["host"], cachedValue.revalidate, lastModified);
+    const cacheControl = await computeCacheControl(localizedPath, body, event.headers.host, cachedValue.revalidate, lastModified);
     return {
         type: "core",
         statusCode: 200,
@@ -130,12 +128,12 @@ export async function cacheInterceptor(event) {
                     return event;
                 }
             }
-            const host = event.headers["host"];
+            const host = event.headers.host;
             switch (cachedData.value?.type) {
                 case "app":
                 case "page":
                     return generateResult(event, localizedPath, cachedData.value, cachedData.lastModified);
-                case "redirect":
+                case "redirect": {
                     const cacheControl = await computeCacheControl(localizedPath, "", host, cachedData.value.revalidate, cachedData.lastModified);
                     return {
                         type: "core",
@@ -148,6 +146,7 @@ export async function cacheInterceptor(event) {
                         },
                         isBase64Encoded: false,
                     };
+                }
                 default:
                     return event;
             }

package/dist/core/routing/i18n/accept-header.js

@@ -11,6 +11,7 @@ function parse(raw, preferences, options) {
             lowers.set(lower, { orig: preference, pos: pos++ });
             if (options.prefixMatch) {
                 const parts = lower.split("-");
+                // biome-ignore lint/style/noCommaOperator:
                 while ((parts.pop(), parts.length > 0)) {
                     const joined = parts.join("-");
                     if (!lowers.has(joined)) {
@@ -32,7 +33,7 @@ function parse(raw, preferences, options) {
         if (params.length > 2) {
             throw new Error(`Invalid ${options.type} header`);
         }
-        let token = params[0].toLowerCase();
+        const token = params[0].toLowerCase();
         if (!token) {
             throw new Error(`Invalid ${options.type} header`);
         }
@@ -47,7 +48,7 @@ function parse(raw, preferences, options) {
             if (!value || (key !== "q" && key !== "Q")) {
                 throw new Error(`Invalid ${options.type} header`);
             }
-            const score = parseFloat(value);
+            const score = Number.parseFloat(value);
             if (score === 0) {
                 continue;
             }

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

@@ -1,14 +1,12 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import type { Header, PrerenderManifest, RedirectDefinition, RewriteDefinition } from "../../types/next-types";
 import type { InternalEvent, InternalResult } from "../../types/open-next";
-export declare function addNextConfigHeaders(event: InternalEvent, configHeaders?: Header[] | undefined): Record<string, string | undefined>;
+export declare function getNextConfigHeaders(event: InternalEvent, configHeaders?: Header[] | undefined): Record<string, string | undefined>;
 export declare function handleRewrites<T extends RewriteDefinition>(event: InternalEvent, rewrites: T[]): {
     internalEvent: {
         rawPath: string;
         url: string;
         method: string;
-        body?: Buffer | undefined;
+        body?: Buffer;
         headers: Record<string, string>;
         query: Record<string, string | string[]>;
         cookies: Record<string, string>;