@opennextjs/aws 3.2.1 → 3.3.0

package/dist/build/helper.js

@@ -21,6 +21,7 @@ export function normalizeOptions(config, distDir, tempBuildDir) {
     else {
         appPackageJsonPath = findNextPackageJsonPath(appPath, monorepoRoot);
     }
+    const debug = Boolean(process.env.OPEN_NEXT_DEBUG) ?? false;
     return {
         appBuildOutputPath: buildOutputPath,
         appPackageJsonPath,
@@ -28,7 +29,9 @@ export function normalizeOptions(config, distDir, tempBuildDir) {
         appPublicPath: path.join(appPath, "public"),
         buildDir: path.join(outputDir, ".build"),
         config,
-        debug: Boolean(process.env.OPEN_NEXT_DEBUG) ?? false,
+        debug,
+        // Whether ESBuild should minify the code
+        minify: !debug,
         monorepoRoot,
         nextVersion: getNextVersion(appPath),
         openNextVersion: getOpenNextVersion(),
@@ -68,13 +71,13 @@ function findNextPackageJsonPath(appPath, root) {
         : path.join(root, "./package.json");
 }
 export function esbuildSync(esbuildOptions, options) {
-    const { openNextVersion, debug } = options;
+    const { openNextVersion, debug, minify } = options;
     const result = buildSync({
         target: "esnext",
         format: "esm",
         platform: "node",
         bundle: true,
-        minify: debug ? false : true,
+        minify,
         mainFields: ["module", "main"],
         sourcemap: debug ? "inline" : false,
         sourcesContent: false,
@@ -95,13 +98,13 @@ export function esbuildSync(esbuildOptions, options) {
     }
 }
 export async function esbuildAsync(esbuildOptions, options) {
-    const { openNextVersion, debug } = options;
+    const { openNextVersion, debug, minify } = options;
     const result = await buildAsync({
         target: "esnext",
         format: "esm",
         platform: "node",
         bundle: true,
-        minify: debug ? false : true,
+        minify,
         mainFields: ["module", "main"],
         sourcemap: debug ? "inline" : false,
         sourcesContent: false,
@@ -125,28 +128,40 @@ export async function esbuildAsync(esbuildOptions, options) {
         throw new Error(`There was a problem bundling ${esbuildOptions.entryPoints[0]}.`);
     }
 }
-export function removeFiles(root, conditionFn, searchingDir = "") {
-    traverseFiles(root, conditionFn, (filePath) => fs.rmSync(filePath, { force: true }), searchingDir);
-}
 /**
  * Recursively traverse files in a directory and call `callbackFn` when `conditionFn` returns true
+ *
+ * The callbacks are passed both the absolute and relative (to root) path to files.
+ *
  * @param root - Root directory to search
- * @param conditionFn - Called to determine if `callbackFn` should be called
- * @param callbackFn - Called when `conditionFn` returns true
+ * @param conditionFn - Called to determine if `callbackFn` should be called.
+ * @param callbackFn - Called when `conditionFn` returns true.
  * @param searchingDir - Directory to search (used for recursion)
  */
 export function traverseFiles(root, conditionFn, callbackFn, searchingDir = "") {
     fs.readdirSync(path.join(root, searchingDir)).forEach((file) => {
-        const filePath = path.join(root, searchingDir, file);
-        if (fs.statSync(filePath).isDirectory()) {
-            traverseFiles(root, conditionFn, callbackFn, path.join(searchingDir, file));
+        const relativePath = path.join(searchingDir, file);
+        const absolutePath = path.join(root, relativePath);
+        if (fs.statSync(absolutePath).isDirectory()) {
+            traverseFiles(root, conditionFn, callbackFn, relativePath);
             return;
         }
-        if (conditionFn(path.join(searchingDir, file))) {
-            callbackFn(filePath);
+        if (conditionFn({ absolutePath, relativePath })) {
+            callbackFn({ absolutePath, relativePath });
         }
     });
 }
+/**
+ * Recursively delete files.
+ *
+ * @see `traverseFiles`.
+ *
+ * @param root Root directory to search.
+ * @param conditionFn Predicate used to delete the files.
+ */
+export function removeFiles(root, conditionFn) {
+    traverseFiles(root, conditionFn, ({ absolutePath }) => fs.rmSync(absolutePath, { force: true }));
+}
 export function getHtmlPages(dotNextPath) {
     // Get a list of HTML pages
     //
@@ -187,9 +202,11 @@ export function compareSemver(v1, v2) {
     if (v1 === "latest")
         return 1;
     if (/^[^\d]/.test(v1)) {
+        // biome-ignore lint/style/noParameterAssign:
         v1 = v1.substring(1);
     }
     if (/^[^\d]/.test(v2)) {
+        // biome-ignore lint/style/noParameterAssign:
         v2 = v2.substring(1);
     }
     const [major1, minor1, patch1] = v1.split(".").map(Number);
@@ -247,3 +264,15 @@ export function initOutputDir(options) {
     fs.mkdirSync(buildDir, { recursive: true });
     fs.cpSync(options.tempBuildDir, buildDir, { recursive: true });
 }
+/**
+ * @returns Whether the edge runtime is used
+ */
+export async function isEdgeRuntime(overrides) {
+    if (!overrides?.wrapper) {
+        return false;
+    }
+    if (typeof overrides.wrapper === "string") {
+        return ["cloudflare-edge", "cloudflare"].includes(overrides.wrapper);
+    }
+    return (await overrides?.wrapper?.())?.edgeRuntime;
+}

package/dist/build/installDeps.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { execSync } from "child_process";
+import { execSync } from "node:child_process";
 import logger from "../logger.js";
 export function installDependencies(outputDir, installOptions) {
     try {

package/dist/build/patch/patchedAsyncStorage.js

@@ -8,7 +8,7 @@ const staticGenerationAsyncStorage = {
         if (store) {
             store.isOnDemandRevalidate =
                 store.isOnDemandRevalidate &&
-                    !globalThis.__als.getStore().isISRRevalidation;
+                    !globalThis.__openNextAls.getStore().isISRRevalidation;
         }
         return store;
     },

package/dist/build/utils.js

@@ -1,12 +1,13 @@
 import os from "node:os";
 import logger from "../logger.js";
 export function printHeader(header) {
+    // biome-ignore lint/style/noParameterAssign:
     header = `OpenNext — ${header}`;
     logger.info([
         "",
-        "┌" + "─".repeat(header.length + 2) + "┐",
+        `┌${"─".repeat(header.length + 2)}┐`,
         `│ ${header} │`,
-        "└" + "─".repeat(header.length + 2) + "┘",
+        `└${"─".repeat(header.length + 2)}┘`,
         "",
     ].join("\n"));
 }

package/dist/build/validateConfig.js

@@ -8,7 +8,10 @@ const compatibilityMatrix = {
     ],
     "aws-lambda-streaming": ["aws-apigw-v2"],
     cloudflare: ["edge"],
+    "cloudflare-edge": ["edge"],
+    "cloudflare-node": ["edge"],
     node: ["node"],
+    dummy: [],
 };
 function validateFunctionOptions(fnOptions) {
     if (fnOptions.runtime === "edge" && fnOptions.experimentalBundledNextServer) {
@@ -62,7 +65,7 @@ export function validateConfig(config) {
         logger.warn("You've disabled incremental cache. This means that ISR and SSG will not work.");
     }
     if (config.dangerous?.disableTagCache) {
-        logger.warn(`You've disabled tag cache. 
+        logger.warn(`You've disabled tag cache.
        This means that revalidatePath and revalidateTag from next/cache will not work.
        It is safe to disable if you only use page router`);
     }

package/dist/core/createGenericHandler.d.ts

@@ -1,7 +1,5 @@
-import type { BaseEventOrResult, InternalEvent, InternalResult, OpenNextConfig, OpenNextHandler } from "../types/open-next";
-declare global {
-    var openNextConfig: Partial<OpenNextConfig>;
-}
+import type { BaseEventOrResult, InternalEvent, InternalResult } from "../types/open-next";
+import type { OpenNextHandler } from "../types/overrides";
 type HandlerType = "imageOptimization" | "revalidate" | "warmer" | "middleware" | "initializationFunction";
 type GenericHandler<Type extends HandlerType, E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> = {
     handler: OpenNextHandler<E, R>;

package/dist/core/createGenericHandler.js

@@ -1,8 +1,7 @@
 import { debug } from "../adapters/logger";
 import { resolveConverter, resolveWrapper } from "./resolve";
 export async function createGenericHandler(handler) {
-    //First we load the config
-    // @ts-expect-error
+    // @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);
     globalThis.openNextConfig = config;
     const override = config[handler.type]

package/dist/core/createMainHandler.d.ts

@@ -1,18 +1 @@
-/// <reference types="node" />
-import type { AsyncLocalStorage } from "node:async_hooks";
-import type { DetachedPromiseRunner } from "../utils/promise";
-import type { IncrementalCache } from "../overrides/incrementalCache/types";
-import type { Queue } from "../overrides/queue/types";
-declare global {
-    var queue: Queue;
-    var incrementalCache: IncrementalCache;
-    var fnName: string | undefined;
-    var serverId: string;
-    var __als: AsyncLocalStorage<{
-        requestId: string;
-        pendingPromiseRunner: DetachedPromiseRunner;
-        isISRRevalidation?: boolean;
-        mergeHeadersPriority?: "middleware" | "handler";
-    }>;
-}
 export declare function createMainHandler(): Promise<(...args: any[]) => any>;

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.d.ts

@@ -1,3 +1,2 @@
-import type { StreamCreator } from "../http/index.js";
-import type { InternalEvent, InternalResult } from "../types/open-next";
+import type { InternalEvent, InternalResult, StreamCreator } from "../types/open-next";
 export declare function openNextHandler(internalEvent: InternalEvent, responseStreaming?: StreamCreator): Promise<InternalResult>;

package/dist/core/requestHandler.js

@@ -1,66 +1,89 @@
 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 routingResult = {
+            internalEvent,
+            isExternalRewrite: false,
+            origin: false,
+            isISR: false,
+        };
+        //#override withRouting
+        try {
+            routingResult = 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 routingResult
+            ? routingResult.headers
+            : routingResult.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];
         }
-        return preprocessResult;
-    }
-    else {
-        const preprocessedEvent = preprocessResult.internalEvent;
+        if ("isExternalRewrite" in routingResult &&
+            routingResult.isExternalRewrite === true) {
+            try {
+                routingResult = await globalThis.proxyExternalRequest.proxy(routingResult.internalEvent);
+            }
+            catch (e) {
+                error("External request failed.", e);
+                routingResult = {
+                    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 routingResult) {
+            // response is used only in the streaming case
+            if (responseStreaming) {
+                const response = createServerResponse(internalEvent, headers, responseStreaming);
+                response.statusCode = routingResult.statusCode;
+                response.flushHeaders();
+                const [bodyToConsume, bodyToReturn] = routingResult.body.tee();
+                for await (const chunk of bodyToConsume) {
+                    response.write(chunk);
+                }
+                response.end();
+                routingResult.body = bodyToReturn;
+            }
+            return routingResult;
+        }
+        const preprocessedEvent = routingResult.internalEvent;
         debug("preprocessedEvent", preprocessedEvent);
         const reqProps = {
             method: preprocessedEvent.method,
@@ -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);
 }