@opennextjs/aws 4.1.7 → 4.1.9

package/dist/adapters/cache.d.ts

@@ -1,4 +1,4 @@
-import type { CacheHandlerValue, IncrementalCacheContext, IncrementalCacheValue } from "../types/cache";
+import type { CacheHandlerValue, IncrementalCacheContext, IncrementalCacheValue } from "../types/cache.js";
 export declare const SOFT_TAG_PREFIX = "_N_T_/";
 export default class Cache {
     get(key: string, options?: boolean | {

package/dist/adapters/cache.js

@@ -1,4 +1,4 @@
-import { getStaleLastModified, getTagsFromValue, hasBeenRevalidated, isStale, writeTags, } from "../utils/cache";
+import { getStaleLastModified, getTagsFromValue, hasBeenRevalidated, isStale, writeTags, } from "../utils/cache.js";
 import { isBinaryContentType } from "../utils/binary";
 import { CACHE_TAGS_HEADER } from "../utils/cacheHeaders";
 import { getPathFromRouteCacheKey } from "../utils/routeCacheKey";
@@ -198,14 +198,15 @@ export default class Cache {
         }
         const store = globalThis.__openNextAls.getStore();
         const writePromise = this.writeCache(key, data, ctx);
-        // Next.js ignores the value returned by `set`, so the write is registered on the request's
-        // pending promise runner instead of being awaited. `FETCH` writes are awaited: Next.js runs
-        // them in a detached chain of its own that only covers the write while `set` waits for it.
+        // Next.js ignores some cache handler results and does not reliably retain
+        // FETCH writes created during a Server Action Flight render. Register every
+        // write with the request runner before preserving FETCH's awaited behavior.
+        if (store !== undefined) {
+            store.pendingPromiseRunner.add(writePromise);
+        }
         if (data?.kind === "FETCH" || store === undefined) {
             await writePromise;
-            return;
         }
-        store.pendingPromiseRunner.add(writePromise);
     }
     async writeCache(key, data, ctx) {
         try {

package/dist/adapters/composable-cache.d.ts

@@ -1,4 +1,4 @@
-import type { ComposableCacheEntry } from "../types/cache";
+import type { ComposableCacheEntry } from "../types/cache.js";
 declare const _default: {
     get(cacheKey: string): Promise<{
         value: import("stream/web").ReadableStream<any>;

package/dist/adapters/composable-cache.js

@@ -1,5 +1,5 @@
-import { isStale, writeTags } from "../utils/cache";
-import { fromReadableStream, toReadableStream } from "../utils/stream";
+import { isStale, writeTags } from "../utils/cache.js";
+import { fromReadableStream, toReadableStream } from "../utils/stream.js";
 import { debug } from "./logger";
 /**
  * In-flight writes are tracked per request, not per module.

package/dist/adapters/config/util.d.ts

@@ -1,4 +1,4 @@
-import type { FunctionsConfigManifest, MiddlewareManifest, NextConfig, PrerenderManifest } from "../../types/next-types";
+import type { FunctionsConfigManifest, MiddlewareManifest, NextConfig, PrerenderManifest } from "../../types/next-types.js";
 import type { PublicFiles } from "../../build";
 export declare function loadConfig(nextDir: string): NextConfig;
 export declare function loadBuildId(nextDir: string): string;
@@ -8,22 +8,22 @@ export declare function loadPublicAssets(openNextDir: string): PublicFiles;
 export declare function loadRoutesManifest(nextDir: string): {
     basePath: string | undefined;
     rewrites: {
-        beforeFiles: import("../../types/next-types").RewriteDefinition[];
-        afterFiles: import("../../types/next-types").RewriteDefinition[];
-        fallback: import("../../types/next-types").RewriteDefinition[];
+        beforeFiles: import("../../types/next-types.js").RewriteDefinition[];
+        afterFiles: import("../../types/next-types.js").RewriteDefinition[];
+        fallback: import("../../types/next-types.js").RewriteDefinition[];
     };
-    redirects: import("../../types/next-types").RedirectDefinition[];
+    redirects: import("../../types/next-types.js").RedirectDefinition[];
     routes: {
-        static: import("../../types/next-types").RouteDefinition[];
-        dynamic: import("../../types/next-types").RouteDefinition[];
+        static: import("../../types/next-types.js").RouteDefinition[];
+        dynamic: import("../../types/next-types.js").RouteDefinition[];
         data: {
-            static: import("../../types/next-types").DataRouteDefinition[];
-            dynamic: import("../../types/next-types").DataRouteDefinition[];
+            static: import("../../types/next-types.js").DataRouteDefinition[];
+            dynamic: import("../../types/next-types.js").DataRouteDefinition[];
         };
     };
     locales: string[];
 };
-export declare function loadConfigHeaders(nextDir: string): import("../../types/next-types").Header[] | undefined;
+export declare function loadConfigHeaders(nextDir: string): import("../../types/next-types.js").Header[] | undefined;
 export declare function loadPrerenderManifest(nextDir: string): PrerenderManifest | undefined;
 export declare function loadAppPathsManifest(nextDir: string): Record<string, string>;
 export declare function loadAppPathRoutesManifest(nextDir: string): Record<string, string>;

package/dist/adapters/edge-adapter.js

@@ -1,5 +1,5 @@
-import { runWithOpenNextRequestContext } from "../utils/promise";
-import { emptyReadableStream } from "../utils/stream";
+import { runWithOpenNextRequestContext } from "../utils/promise.js";
+import { emptyReadableStream } from "../utils/stream.js";
 // We import it like that so that the edge plugin can replace it
 import { NextConfig } from "../adapters/config";
 import { createGenericHandler } from "../core/createGenericHandler";

package/dist/adapters/middleware.js

@@ -1,5 +1,5 @@
-import { ISR_HEADER } from "../utils/cacheHeaders";
-import { runWithOpenNextRequestContext } from "../utils/promise";
+import { ISR_HEADER } from "../utils/cacheHeaders.js";
+import { runWithOpenNextRequestContext } from "../utils/promise.js";
 import { debug, error } from "../adapters/logger";
 import { createGenericHandler } from "../core/createGenericHandler";
 import { resolveAssetResolver, resolveIncrementalCache, resolveOriginResolver, resolveProxyRequest, resolveQueue, resolveTagCache, } from "../core/resolve";

package/dist/build/copyTracedFiles.js

@@ -319,8 +319,12 @@ File ${serverPath} does not exist
     }
     // Copy .next/static/css from standalone to output dir
     // needed for optimizeCss feature to work
-    if (config.experimental.optimizeCss) {
-        cpSync(path.join(standaloneNextDir, "static", "css"), path.join(outputNextDir, "static", "css"), { recursive: true });
+    // The directory is not emitted when all the css is inlined
+    const standaloneCssDir = path.join(standaloneNextDir, "static", "css");
+    if (config.experimental.optimizeCss && existsSync(standaloneCssDir)) {
+        cpSync(standaloneCssDir, path.join(outputNextDir, "static", "css"), {
+            recursive: true,
+        });
     }
     logger.debug("copyTracedFiles:", Date.now() - tsStart, "ms");
     return {

package/dist/build/edge/createEdgeBundle.d.ts

@@ -1,6 +1,6 @@
 import { type Plugin } from "esbuild";
-import type { MiddlewareInfo } from "../../types/next-types";
-import type { IncludedConverter, IncludedOriginResolver, LazyLoadedOverride, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
+import type { MiddlewareInfo } from "../../types/next-types.js";
+import type { IncludedConverter, IncludedOriginResolver, LazyLoadedOverride, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next.js";
 import type { OriginResolver } from "../../types/overrides.js";
 import { ContentUpdater } from "../../plugins/content-updater.js";
 import { type BuildOptions } from "../helper.js";

package/dist/build/installDeps.d.ts

@@ -1,2 +1,2 @@
-import type { InstallOptions } from "../types/open-next";
+import type { InstallOptions } from "../types/open-next.js";
 export declare function installDependencies(outputDir: string, installOptions?: InstallOptions): void;

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

@@ -1,9 +1,10 @@
-export declare const rule = "\nrule:\n  kind: binary_expression\n  all:\n    - has:\n        kind: unary_expression\n        pattern: \"!$ENTRY.isStale\"\n    -  has:\n         kind: member_expression\n         regex: \"context.isPrefetch\"\nfix:\n  'true'";
+export declare const rule = "\nrule:\n  kind: binary_expression\n  # The names are mangled in the minified runtimes\n  pattern: \"!$ENTRY.isStale || $CONTEXT.isPrefetch\"\n  all:\n    # It has to be the whole check, not a part of a bigger expression\n    - not:\n        inside:\n          kind: binary_expression\n    # It has to be guarded by the on-demand revalidation check\n    - inside:\n        kind: if_statement\n        stopBy: end\n        has:\n          field: condition\n          stopBy: end\n          any:\n            # Next 15.5+ and its minified runtime copies use the same context object\n            - pattern: \"!$CONTEXT.isOnDemandRevalidate\"\n            # Earlier unminified versions keep this flag in a local\n            - pattern: \"!isOnDemandRevalidate\"\nfix:\n  'true'";
 export declare const patchBackgroundRevalidation: {
     name: string;
     patches: {
         versions: ">=14.1.0";
         pathFilter: RegExp;
+        contentFilter: RegExp;
         patchCode: import("../codePatcher.js").PatchCodeFn;
     }[];
 };

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

@@ -1,15 +1,31 @@
 import { getCrossPlatformPathRegex } from "../../../utils/regex.js";
 import { createPatchCode } from "../astCodePatcher.js";
+// Matches the check that decides whether a cached entry can be served as is in `ResponseCache.get`:
+//   if (entry && !context.isOnDemandRevalidate) { ...; if (!entry.isStale || context.isPrefetch) return ... }
+// which is minified in the compiled runtimes as:
+//   if ((a = ...) && !r.isOnDemandRevalidate && (n(a), i = !0, !a.isStale || r.isPrefetch)) return a;
 export const rule = `
 rule:
   kind: binary_expression
+  # The names are mangled in the minified runtimes
+  pattern: "!$ENTRY.isStale || $CONTEXT.isPrefetch"
   all:
-    - has:
-        kind: unary_expression
-        pattern: "!$ENTRY.isStale"
-    -  has:
-         kind: member_expression
-         regex: "context.isPrefetch"
+    # It has to be the whole check, not a part of a bigger expression
+    - not:
+        inside:
+          kind: binary_expression
+    # It has to be guarded by the on-demand revalidation check
+    - inside:
+        kind: if_statement
+        stopBy: end
+        has:
+          field: condition
+          stopBy: end
+          any:
+            # Next 15.5+ and its minified runtime copies use the same context object
+            - pattern: "!$CONTEXT.isOnDemandRevalidate"
+            # Earlier unminified versions keep this flag in a local
+            - pattern: "!isOnDemandRevalidate"
 fix:
   'true'`;
 export const patchBackgroundRevalidation = {
@@ -18,7 +34,10 @@ export const patchBackgroundRevalidation = {
         {
             // TODO: test for earlier versions of Next
             versions: ">=14.1.0",
-            pathFilter: getCrossPlatformPathRegex("server/response-cache/index.js"),
+            // Since Next 15.5 route modules use their own `ResponseCache`, which is inlined (and minified)
+            // in `next/dist/compiled/next-server/*.runtime.prod.js`
+            pathFilter: getCrossPlatformPathRegex(String.raw `(server/response-cache/index\.js|\.runtime\.prod\.js)$`, { escape: false }),
+            contentFilter: /\.isStale\s*\|\|\s*[\w$]+\.isPrefetch/,
             patchCode: createPatchCode(rule),
         },
     ],

package/dist/build/validateConfig.d.ts

@@ -1,2 +1,2 @@
-import type { OpenNextConfig } from "../types/open-next";
+import type { OpenNextConfig } from "../types/open-next.js";
 export declare function validateConfig(config: OpenNextConfig): void;

package/dist/core/createGenericHandler.d.ts

@@ -1,5 +1,5 @@
-import type { BaseEventOrResult, InternalEvent, InternalResult } from "../types/open-next";
-import type { OpenNextHandler } from "../types/overrides";
+import type { BaseEventOrResult, InternalEvent, InternalResult } from "../types/open-next.js";
+import type { OpenNextHandler } from "../types/overrides.js";
 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/edgeFunctionHandler.d.ts

@@ -1,4 +1,4 @@
-import type { RequestData } from "../types/global";
+import type { RequestData } from "../types/global.js";
 type EdgeRequest = Omit<RequestData, "page">;
 export default function edgeFunctionHandler(request: EdgeRequest): Promise<Response>;
 export {};

package/dist/core/nodeMiddlewareHandler.d.ts

@@ -1,4 +1,4 @@
-import type { RequestData } from "../types/global";
+import type { RequestData } from "../types/global.js";
 type EdgeRequest = Omit<RequestData, "page">;
 export default function middlewareHandler(request: EdgeRequest): Promise<Response>;
 export {};

package/dist/core/requestHandler.d.ts

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

package/dist/core/requestHandler.js

@@ -1,11 +1,11 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { IncomingMessage } from "../http/index.js";
-import { ISR_HEADER } from "../utils/cacheHeaders";
-import { runWithOpenNextRequestContext } from "../utils/promise";
-import { NextConfig } from "../adapters/config/index";
+import { ISR_HEADER } from "../utils/cacheHeaders.js";
+import { runWithOpenNextRequestContext } from "../utils/promise.js";
+import { NextConfig } from "../adapters/config/index.js";
 import { debug, error } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
-import { constructNextUrl, convertRes, convertToQuery, convertToQueryString, createServerResponse, } from "./routing/util";
+import { constructNextUrl, convertRes, convertToQuery, createServerResponse, } from "./routing/util";
 import routingHandler, { INTERNAL_EVENT_REQUEST_ID, INTERNAL_HEADER_REWRITE_STATUS_CODE, INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
 import { requestHandler, setNextjsPrebundledReact } from "./util";
 // This is used to identify requests in the cache
@@ -161,6 +161,14 @@ export async function openNextHandler(internalEvent, options) {
         return internalResult;
     });
 }
+/**
+ * Applies routing metadata and invokes the Next.js request handler.
+ *
+ * @param req The request passed to Next.js
+ * @param res The response populated by Next.js
+ * @param routingResult The resolved OpenNext route and request metadata
+ * @return A promise that resolves after Next.js handles the request
+ */
 async function processRequest(req, res, routingResult) {
     // @ts-ignore
     // Next.js doesn't parse body if the property exists
@@ -202,9 +210,9 @@ async function processRequest(req, res, routingResult) {
         // TODO: only enable this on Next 15.4+
         // We need to set the pathname to the data request path
         //#override setInitialURL
-        req.url =
-            initialURL.pathname +
-                convertToQueryString(routingResult.internalEvent.query);
+        // `invokeQuery` carries destination query values for server APIs, while
+        // `req.url` remains the browser-visible URL used by the App Router state.
+        req.url = initialURL.pathname + initialURL.search;
         //#endOverride
         await requestHandler(requestMetadata)(req, res);
     }

package/dist/core/resolve.d.ts

@@ -1,5 +1,5 @@
-import type { BaseEventOrResult, DefaultOverrideOptions, ExternalMiddlewareConfig, InternalEvent, InternalResult, OpenNextConfig, OverrideOptions } from "../types/open-next";
-import type { Converter, TagCache, Wrapper } from "../types/overrides";
+import type { BaseEventOrResult, DefaultOverrideOptions, ExternalMiddlewareConfig, InternalEvent, InternalResult, OpenNextConfig, OverrideOptions } from "../types/open-next.js";
+import type { Converter, TagCache, Wrapper } from "../types/overrides.js";
 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>>;
@@ -16,40 +16,40 @@ export declare function resolveTagCache(tagCache: OverrideOptions["tagCache"]):
  * @returns
  * @__PURE__
  */
-export declare function resolveQueue(queue: OverrideOptions["queue"]): Promise<import("../types/overrides").Queue>;
+export declare function resolveQueue(queue: OverrideOptions["queue"]): Promise<import("../types/overrides.js").Queue>;
 /**
  *
  * @param incrementalCache
  * @returns
  * @__PURE__
  */
-export declare function resolveIncrementalCache(incrementalCache: OverrideOptions["incrementalCache"]): Promise<import("../types/overrides").IncrementalCache>;
+export declare function resolveIncrementalCache(incrementalCache: OverrideOptions["incrementalCache"]): Promise<import("../types/overrides.js").IncrementalCache>;
 /**
  * @param imageLoader
  * @returns
  * @__PURE__
  */
-export declare function resolveImageLoader(imageLoader: RemoveUndefined<OpenNextConfig["imageOptimization"]>["loader"]): Promise<import("../types/overrides").ImageLoader>;
+export declare function resolveImageLoader(imageLoader: RemoveUndefined<OpenNextConfig["imageOptimization"]>["loader"]): Promise<import("../types/overrides.js").ImageLoader>;
 /**
  * @returns
  * @__PURE__
  */
-export declare function resolveOriginResolver(originResolver: RemoveUndefined<ExternalMiddlewareConfig>["originResolver"]): Promise<import("../types/overrides").OriginResolver>;
+export declare function resolveOriginResolver(originResolver: RemoveUndefined<ExternalMiddlewareConfig>["originResolver"]): Promise<import("../types/overrides.js").OriginResolver>;
 /**
  * @returns
  * @__PURE__
  */
-export declare function resolveAssetResolver(assetResolver: RemoveUndefined<OpenNextConfig["middleware"]>["assetResolver"]): Promise<import("../types/overrides").AssetResolver>;
+export declare function resolveAssetResolver(assetResolver: RemoveUndefined<OpenNextConfig["middleware"]>["assetResolver"]): Promise<import("../types/overrides.js").AssetResolver>;
 /**
  * @__PURE__
  */
-export declare function resolveWarmerInvoke(warmer: RemoveUndefined<OpenNextConfig["warmer"]>["invokeFunction"]): Promise<import("../types/overrides").Warmer>;
+export declare function resolveWarmerInvoke(warmer: RemoveUndefined<OpenNextConfig["warmer"]>["invokeFunction"]): Promise<import("../types/overrides.js").Warmer>;
 /**
  * @__PURE__
  */
-export declare function resolveProxyRequest(proxyRequest: OverrideOptions["proxyExternalRequest"]): Promise<import("../types/overrides").ProxyExternalRequest>;
+export declare function resolveProxyRequest(proxyRequest: OverrideOptions["proxyExternalRequest"]): Promise<import("../types/overrides.js").ProxyExternalRequest>;
 /**
  * @__PURE__
  */
-export declare function resolveCdnInvalidation(cdnInvalidation: OverrideOptions["cdnInvalidation"]): Promise<import("../types/overrides").CDNInvalidationHandler>;
+export declare function resolveCdnInvalidation(cdnInvalidation: OverrideOptions["cdnInvalidation"]): Promise<import("../types/overrides.js").CDNInvalidationHandler>;
 export {};

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

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

package/dist/core/routing/cacheInterceptor.js

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
-import { AppPathsManifest, NextConfig, PagesManifest, PrerenderManifest, } from "../../adapters/config/index";
-import { emptyReadableStream, toReadableStream } from "../../utils/stream";
-import { isBinaryContentType } from "../../utils/binary";
-import { getTagsFromValue, hasBeenRevalidated, isStale } from "../../utils/cache";
-import { CACHE_CONTROL_HEADER, NO_STORE_CACHE_CONTROL, OPEN_NEXT_CACHE_HEADER, PRERENDER_REVALIDATE_HEADER, fixCacheControlForError, } from "../../utils/cacheHeaders";
-import { getDynamicRouteCachePathname, getPrerenderRouteCacheKey, getRouteCacheKey, getRouteCacheOwner, useRouteCacheKeys, } from "../../utils/routeCacheKey";
+import { AppPathsManifest, NextConfig, PagesManifest, PrerenderManifest, } from "../../adapters/config/index.js";
+import { emptyReadableStream, toReadableStream } from "../../utils/stream.js";
+import { isBinaryContentType } from "../../utils/binary.js";
+import { getTagsFromValue, hasBeenRevalidated, isStale } from "../../utils/cache.js";
+import { CACHE_CONTROL_HEADER, NO_STORE_CACHE_CONTROL, OPEN_NEXT_CACHE_HEADER, PRERENDER_REVALIDATE_HEADER, fixCacheControlForError, } from "../../utils/cacheHeaders.js";
+import { getDynamicRouteCachePathname, getPrerenderRouteCacheKey, getRouteCacheKey, getRouteCacheOwner, useRouteCacheKeys, } from "../../utils/routeCacheKey.js";
 import { debug } from "../../adapters/logger";
 import { localizePath } from "./i18n";
 import { generateMessageGroupId } from "./queue";

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

@@ -1,5 +1,5 @@
-import type { DomainLocale, i18nConfig } from "../../../types/next-types";
-import type { InternalEvent, InternalResult } from "../../../types/open-next";
+import type { DomainLocale, i18nConfig } from "../../../types/next-types.js";
+import type { InternalEvent, InternalResult } from "../../../types/open-next.js";
 /**
  * @param arg an object containing the hostname and detectedLocale
  * @returns The `DomainLocale` object if a domain is detected, `undefined` otherwise

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

@@ -1,12 +1,53 @@
-import type { Header, PrerenderManifest, RedirectDefinition, RewriteDefinition } from "../../types/next-types";
-import type { InternalEvent, InternalResult } from "../../types/open-next";
+import type { Header, PrerenderManifest, RedirectDefinition, RewriteDefinition } from "../../types/next-types.js";
+import type { InternalEvent, InternalResult } from "../../types/open-next.js";
+/**
+ * Returns the compiled regular expression for a configured pattern.
+ *
+ * Patterns come from the Next.js config and manifests, so each one is compiled
+ * on first use and reused by later requests. `lastIndex` is reset on every call
+ * so a shared global or sticky expression always starts from the beginning.
+ *
+ * @param pattern The regular expression source
+ * @param flags The optional regular expression flags
+ * @returns The compiled regular expression
+ * @throws {SyntaxError} When the pattern is invalid
+ */
+export declare function getCompiledRegExp(pattern: string, flags?: string): RegExp;
+/**
+ * Resolves configured response headers for a request.
+ *
+ * Source parameters are merged with successful condition parameters before
+ * interpolation, with condition parameters taking precedence. See
+ * https://github.com/vercel/next.js/blob/ae745ba/packages/next/src/server/lib/router-utils/resolve-routes.ts#L400-L414
+ *
+ * @param event The request used to match configured headers
+ * @param configHeaders The configured header routes
+ * @returns The response headers produced by every matching route
+ * @throws {SyntaxError} When a configured route pattern is invalid
+ */
 export declare function getNextConfigHeaders(event: InternalEvent, configHeaders?: Header[] | undefined): Record<string, string | undefined>;
 /**
- * TODO: This method currently only check for the first match.
- *       It should check for all matches for `beforeFiles` and `afterFiles` rewrite
- *       See https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites
+ * Applies the first matching rewrite to an internal request.
+ *
+ * Only successful `has` predicates supply destination parameters. Nonmatching
+ * `missing` predicates must not manufacture captures from absent values. See
+ * https://github.com/vercel/next.js/blob/ae745ba/packages/next/src/shared/lib/router/utils/prepare-destination.ts#L113-L125
+ *
+ * Destination queries use non-path compilation so repeated parameters retain
+ * their separators. See
+ * https://github.com/vercel/next.js/blob/ae745ba/packages/next/src/shared/lib/router/utils/prepare-destination.ts#L292-L302
+ *
+ * TODO: This method currently only checks the first match. It should check all
+ * matches for `beforeFiles` and `afterFiles` rewrites. See
+ * https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites
+ *
+ * @param event The request to rewrite
+ * @param rewrites The configured rewrites to evaluate
+ * @param appendParamsToQuery Whether unused match parameters are added to the query
+ * @returns The rewritten request and matched rewrite metadata
+ * @throws {TypeError} When a matched destination cannot be compiled
  */
-export declare function handleRewrites<T extends RewriteDefinition>(event: InternalEvent, rewrites: T[]): {
+export declare function handleRewrites<T extends RewriteDefinition>(event: InternalEvent, rewrites: T[], appendParamsToQuery?: boolean): {
     internalEvent: {
         query: Record<string, string | string[]>;
         rawPath: string;
@@ -21,6 +62,20 @@ export declare function handleRewrites<T extends RewriteDefinition>(event: Inter
     __rewrite: T | undefined;
     isExternalRewrite: boolean;
 };
+/**
+ * Applies every matching `beforeFiles` rewrite, in order.
+ *
+ * Next.js keeps evaluating `beforeFiles` rewrites after a match, each one
+ * against the URL produced by the previous match. An external rewrite ends the
+ * evaluation. See
+ * https://github.com/vercel/next.js/blob/ae745ba/packages/next/src/server/lib/router-utils/resolve-routes.ts#L863-L932
+ *
+ * @param event The request to rewrite
+ * @param rewrites The configured `beforeFiles` rewrites
+ * @returns The rewritten request and the last matched rewrite metadata
+ * @throws {TypeError} When a matched destination cannot be compiled
+ */
+export declare function handleBeforeFilesRewrites<T extends RewriteDefinition>(event: InternalEvent, rewrites: T[]): ReturnType<typeof handleRewrites<T>>;
 export declare function handleRedirects(event: InternalEvent, redirects: RedirectDefinition[]): InternalResult | undefined;
 export declare function fixDataPage(internalEvent: InternalEvent, buildId: string): InternalEvent | InternalResult;
 export declare function handleFallbackFalse(internalEvent: InternalEvent, prerenderManifest?: PrerenderManifest): {