@opennextjs/aws 4.1.10 → 4.1.11

package/dist/build/createImageOptimizationBundle.js

@@ -74,7 +74,7 @@ export async function createImageOptimizationBundle(options) {
     // Sharp provides pre-build binaries for all platforms. https://github.com/lovell/sharp/blob/main/docs/install.md#cross-platform
     // Target should be same as used by Lambda, see https://github.com/sst/sst/blob/ca6f763fdfddd099ce2260202d0ce48c72e211ea/packages/sst/src/constructs/NextjsSite.ts#L114
     // For SHARP_IGNORE_GLOBAL_LIBVIPS see: https://github.com/lovell/sharp/blob/main/docs/install.md#aws-lambda
-    const sharpVersion = process.env.SHARP_VERSION ?? "0.35.4";
+    const sharpVersion = process.env.SHARP_VERSION ?? "0.35.5";
     // In development, we want to use the local machine settings
     const isDev = config.imageOptimization?.loader === "fs-dev";
     installDependencies(outputPath, config.imageOptimization?.install ?? {

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

@@ -1,3 +1,13 @@
 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";
+/**
+ * Keeps the runtime alive until a fetch cache entry is written.
+ *
+ * Next writes the fetch cache in the background (`res.arrayBuffer().then(...)`) without a `waitUntil`.
+ * The write is registered like the `waitUntil` provided to Next (see `provideNextAfterProvider`):
+ * with the runtime `waitUntil` when available, so that writes starting after the request has been
+ * drained (background revalidation) are covered, otherwise with the `pendingPromiseRunner`.
+ *
+ * The fix evaluates to the original promise, Next 15.4+ awaits it.
+ */
+export declare const rule = "\nrule:\n  kind: call_expression\n  pattern: $PROMISE\n  all:\n    # `x.arrayBuffer().then(...).catch(...).finally(...)`.\n    # Arguments are not searched so that enclosing calls (`getTracer().trace(...)` up to Next 15.4)\n    # and the patched code do not match.\n    - has: { pattern: $_.arrayBuffer().then, stopBy: { kind: arguments } }\n    - has: { pattern: \"Buffer.from\", stopBy: end }\n    - has: { pattern: $_.FETCH, stopBy: end }\n    - any:\n        - inside: { kind: sequence_expression, inside: { kind: return_statement } }\n        - inside: { kind: expression_statement, precedes: { kind: return_statement } }\n        # Next 15.4+: `const cacheSetPromise = cloned1.arrayBuffer().then(...)`\n        - inside: { kind: variable_declarator }\n\nfix: |\n  ((promise) => {\n    const store = globalThis.__openNextAls?.getStore();\n    if (store?.waitUntil) {\n      store.waitUntil(promise);\n    } else {\n      store?.pendingPromiseRunner.add(promise);\n    }\n    return promise;\n  })($PROMISE)\n";
 export declare const patchFetchCacheSetMissingWaitUntil: CodePatcher;

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

@@ -1,25 +1,42 @@
 import { getCrossPlatformPathRegex } from "../../../utils/regex.js";
 import { createPatchCode } from "../astCodePatcher.js";
+/**
+ * Keeps the runtime alive until a fetch cache entry is written.
+ *
+ * Next writes the fetch cache in the background (`res.arrayBuffer().then(...)`) without a `waitUntil`.
+ * The write is registered like the `waitUntil` provided to Next (see `provideNextAfterProvider`):
+ * with the runtime `waitUntil` when available, so that writes starting after the request has been
+ * drained (background revalidation) are covered, otherwise with the `pendingPromiseRunner`.
+ *
+ * The fix evaluates to the original promise, Next 15.4+ awaits it.
+ */
 export const rule = `
 rule:
   kind: call_expression
   pattern: $PROMISE
   all:
-    - has: { pattern: $_.arrayBuffer().then, stopBy: end }
+    # \`x.arrayBuffer().then(...).catch(...).finally(...)\`.
+    # Arguments are not searched so that enclosing calls (\`getTracer().trace(...)\` up to Next 15.4)
+    # and the patched code do not match.
+    - has: { pattern: $_.arrayBuffer().then, stopBy: { kind: arguments } }
     - has: { pattern: "Buffer.from", stopBy: end }
-    - any:
-        - inside:
-            kind: sequence_expression
-            inside:
-                kind: return_statement
-        - inside:
-            kind: expression_statement
-            precedes:
-                kind: return_statement
     - has: { pattern: $_.FETCH, stopBy: end }
+    - any:
+        - inside: { kind: sequence_expression, inside: { kind: return_statement } }
+        - inside: { kind: expression_statement, precedes: { kind: return_statement } }
+        # Next 15.4+: \`const cacheSetPromise = cloned1.arrayBuffer().then(...)\`
+        - inside: { kind: variable_declarator }
 
 fix: |
-  globalThis.__openNextAls?.getStore()?.pendingPromiseRunner.add($PROMISE)
+  ((promise) => {
+    const store = globalThis.__openNextAls?.getStore();
+    if (store?.waitUntil) {
+      store.waitUntil(promise);
+    } else {
+      store?.pendingPromiseRunner.add(promise);
+    }
+    return promise;
+  })($PROMISE)
 `;
 export const patchFetchCacheSetMissingWaitUntil = {
     name: "patch-fetch-cache-set-missing-wait-until",

package/dist/core/requestHandler.d.ts

@@ -1,3 +1,28 @@
-import type { InternalEvent, InternalResult } from "../types/open-next.js";
+import type { OpenNextNodeResponse } from "../http/index.js";
+import { IncomingMessage } from "../http/index.js";
+import type { InternalEvent, InternalResult, RoutingResult } from "../types/open-next.js";
 import type { OpenNextHandlerOptions } from "../types/overrides.js";
 export declare function openNextHandler(internalEvent: InternalEvent, options?: OpenNextHandlerOptions): Promise<InternalResult>;
+/**
+ * Renders the next resolved route after a `fallback: false` route threw a `NoFallbackError`.
+ *
+ * Mirrors the Next.js router server, which retries the next matching route:
+ * - Up to six attempts are made, including the initial render, before rendering a 500.
+ * - A 404 is rendered when no route candidate is left.
+ * - Another `NoFallbackError` retries the following candidate, any other error renders a 500.
+ *
+ * Next.js 16.4+ only renders the most specific route unless the route to render is passed as a
+ * `match` request meta (see `getRouteMatchMetadata`). A 400 is rendered when the params of that
+ * match can't be decoded, like Next.js does for a `DecodeError`. Older versions select the route
+ * from `invokeOutput` and receive exactly the same metadata as before.
+ *
+ * Errors are rendered as responses, this function does not throw.
+ *
+ * @param req The request reused for each rendering attempt
+ * @param res The response populated by Next.js
+ * @param routingResult The ordered route candidates and internal request
+ * @param metadata The request metadata of the initial attempt, mutated by Next.js (i.e. it contains the stale `match`)
+ * @param index The next candidate index, counting the initial render as index 0
+ * @return A promise that resolves after rendering a route or an error response
+ */
+export declare function handleNoFallbackError(req: IncomingMessage, res: OpenNextNodeResponse, routingResult: RoutingResult, metadata: Record<string, unknown>, index?: number): Promise<void>;

package/dist/core/requestHandler.js

@@ -2,9 +2,11 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { IncomingMessage } from "../http/index.js";
 import { ISR_HEADER } from "../utils/cacheHeaders.js";
 import { runWithOpenNextRequestContext } from "../utils/promise.js";
+import { compareSemver } from "../utils/semver.js";
 import { NextConfig } from "../adapters/config/index.js";
 import { debug, error } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
+import { getRouteMatchMetadata } from "./routeMatchMetadata";
 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";
@@ -227,8 +229,33 @@ async function processRequest(req, res, routingResult) {
         }
     }
 }
-async function handleNoFallbackError(req, res, routingResult, metadata, index = 1) {
-    if (index >= 5) {
+// Rendering attempts (including the initial one) when falling through `fallback: false` routes.
+// The Next.js router server allows `handleIndex` 0..5 (`if (handleIndex > 5)`) since 13.4.13.
+const MAX_RENDER_ATTEMPTS = 6;
+/**
+ * Renders the next resolved route after a `fallback: false` route threw a `NoFallbackError`.
+ *
+ * Mirrors the Next.js router server, which retries the next matching route:
+ * - Up to six attempts are made, including the initial render, before rendering a 500.
+ * - A 404 is rendered when no route candidate is left.
+ * - Another `NoFallbackError` retries the following candidate, any other error renders a 500.
+ *
+ * Next.js 16.4+ only renders the most specific route unless the route to render is passed as a
+ * `match` request meta (see `getRouteMatchMetadata`). A 400 is rendered when the params of that
+ * match can't be decoded, like Next.js does for a `DecodeError`. Older versions select the route
+ * from `invokeOutput` and receive exactly the same metadata as before.
+ *
+ * Errors are rendered as responses, this function does not throw.
+ *
+ * @param req The request reused for each rendering attempt
+ * @param res The response populated by Next.js
+ * @param routingResult The ordered route candidates and internal request
+ * @param metadata The request metadata of the initial attempt, mutated by Next.js (i.e. it contains the stale `match`)
+ * @param index The next candidate index, counting the initial render as index 0
+ * @return A promise that resolves after rendering a route or an error response
+ */
+export async function handleNoFallbackError(req, res, routingResult, metadata, index = 1) {
+    if (index >= MAX_RENDER_ATTEMPTS) {
         await tryRenderError("500", res, routingResult.internalEvent);
         return;
     }
@@ -236,11 +263,29 @@ async function handleNoFallbackError(req, res, routingResult, metadata, index =
         await tryRenderError("404", res, routingResult.internalEvent);
         return;
     }
+    const route = routingResult.resolvedRoutes[index].route;
     try {
+        // Skip the call itself on older versions: decoding here can change their error handling.
+        let routeMatchMetadata = {};
+        if (compareSemver(globalThis.nextVersion, ">=", "16.4.0")) {
+            try {
+                routeMatchMetadata = getRouteMatchMetadata(route, routingResult.internalEvent.rawPath);
+            }
+            catch (e) {
+                // Only match decoding is a bad request; rendering errors still use the 500 path.
+                if (!(e instanceof URIError)) {
+                    throw e;
+                }
+                await tryRenderError("400", res, routingResult.internalEvent);
+                return;
+            }
+        }
         await requestHandler({
             ...routingResult,
-            invokeOutput: routingResult.resolvedRoutes[index].route,
+            invokeOutput: route,
             ...metadata,
+            // Must come after `metadata` to override the stale `match` of the previous attempt.
+            ...routeMatchMetadata,
         })(req, res);
     }
     catch (e) {
@@ -253,6 +298,16 @@ async function handleNoFallbackError(req, res, routingResult, metadata, index =
         }
     }
 }
+/**
+ * Renders a Next.js error response with fresh request metadata.
+ *
+ * Falls back to a JSON 500 response if rendering the error page fails.
+ *
+ * @param type The HTTP error status to render
+ * @param res The response populated by Next.js
+ * @param internalEvent The request supplying headers, body, and remote address
+ * @return A promise that resolves after writing the error response
+ */
 async function tryRenderError(type, res, internalEvent) {
     try {
         const _req = new IncomingMessage({
@@ -262,11 +317,11 @@ async function tryRenderError(type, res, internalEvent) {
             body: internalEvent.body,
             remoteAddress: internalEvent.remoteAddress,
         });
-        // By setting this it will allow us to bypass and directly render the 404 or 500 page
+        // Bypass route matching and directly render the requested error response.
         const requestMetadata = {
             // By setting invokePath and invokeQuery we can bypass some of the routing logic in Next.js
-            invokePath: type === "404" ? "/404" : "/500",
-            invokeStatus: type === "404" ? 404 : 500,
+            invokePath: `/${type}`,
+            invokeStatus: Number(type),
             middlewareInvoke: false,
         };
         await requestHandler(requestMetadata)(_req, res);

package/dist/core/routeMatchMetadata.d.ts

@@ -0,0 +1,27 @@
+import type { RouteMatch } from "../types/next-types.js";
+/**
+ * Returns the request metadata selecting `route` for `pathname`.
+ *
+ * Next.js 16.4 removed the route matcher manager from the base server: it now only renders the
+ * most specific route matching the pathname, and `invokeOutput` can skip that route but no
+ * longer selects another one. The Next.js router server forwards the route to render as a
+ * `match` request metadata instead, which is required to retry the next route after a
+ * `NoFallbackError` (i.e. a `fallback: false` page which was not prerendered).
+ *
+ * Next.js mutates the metadata of the previous attempt, which then contains the `match` of the
+ * route which threw the `NoFallbackError`. `match` is always returned (possibly `undefined`) so
+ * that it overrides this stale match even when the route can't be matched.
+ *
+ * Only used for Next.js 16.4+. Older versions retain their matcher-based retry path,
+ * including parameter-decoding error handling, without calling this helper.
+ *
+ * @param route The route pattern selected for the retry, i.e. `/blog/[slug]`
+ * @param pathname The encoded internal pathname after routing, which may include the basePath, a locale prefix and
+ *   a trailing slash
+ * @return Metadata selecting the route, or `{ match: undefined }` when the route is unknown or doesn't match the
+ *   pathname (Next.js then renders a 404)
+ * @throws {URIError} If a captured parameter contains malformed percent encoding
+ */
+export declare function getRouteMatchMetadata(route: string, pathname: string): {
+    match: RouteMatch | undefined;
+};

package/dist/core/routeMatchMetadata.js

@@ -0,0 +1,146 @@
+import path from "node:path";
+import { AppPathRoutesManifest, AppPathsManifest, NEXT_DIR, NextConfig, PagesManifest, RoutesManifest, } from "../adapters/config/index.js";
+import { normalizeLocalePath, selectAppPageEntry, } from "../utils/routeCacheKey.js";
+// `[slug]`, `[...slug]` or `[[...slug]]`, possibly after an interception marker like `(.)`
+const DYNAMIC_SEGMENT_REGEX = /\[{1,2}(\.\.\.)?([^\]]+)\]{1,2}$/;
+/**
+ * Returns the request metadata selecting `route` for `pathname`.
+ *
+ * Next.js 16.4 removed the route matcher manager from the base server: it now only renders the
+ * most specific route matching the pathname, and `invokeOutput` can skip that route but no
+ * longer selects another one. The Next.js router server forwards the route to render as a
+ * `match` request metadata instead, which is required to retry the next route after a
+ * `NoFallbackError` (i.e. a `fallback: false` page which was not prerendered).
+ *
+ * Next.js mutates the metadata of the previous attempt, which then contains the `match` of the
+ * route which threw the `NoFallbackError`. `match` is always returned (possibly `undefined`) so
+ * that it overrides this stale match even when the route can't be matched.
+ *
+ * Only used for Next.js 16.4+. Older versions retain their matcher-based retry path,
+ * including parameter-decoding error handling, without calling this helper.
+ *
+ * @param route The route pattern selected for the retry, i.e. `/blog/[slug]`
+ * @param pathname The encoded internal pathname after routing, which may include the basePath, a locale prefix and
+ *   a trailing slash
+ * @return Metadata selecting the route, or `{ match: undefined }` when the route is unknown or doesn't match the
+ *   pathname (Next.js then renders a 404)
+ * @throws {URIError} If a captured parameter contains malformed percent encoding
+ */
+export function getRouteMatchMetadata(route, pathname) {
+    const definition = getRouteDefinition(route);
+    const params = definition
+        ? getRouteParams(route, normalizePathname(pathname))
+        : null;
+    return {
+        match: definition && params !== null ? { definition, params } : undefined,
+    };
+}
+/**
+ * Resolves a route to its Next.js definition from the manifests.
+ *
+ * App pages take precedence over app route handlers, then pages (`/api` and `/api/*` are pages API routes).
+ * For app pages, the canonical entry is selected like Next.js when a route has parallel slots or route groups.
+ *
+ * @param route The route pattern selected for the retry, i.e. `/blog/[slug]`
+ * @return The route definition, or `undefined` when the route is in none of the manifests
+ */
+function getRouteDefinition(route) {
+    const appPaths = Object.keys(AppPathRoutesManifest).filter((appPath) => AppPathRoutesManifest[appPath] === route);
+    const appPages = appPaths.filter((appPath) => appPath.endsWith("/page"));
+    // Select the same canonical entry as Next.js and the route cache owner.
+    const appPage = selectAppPageEntry(route, appPages);
+    if (appPage) {
+        return {
+            kind: "APP_PAGE",
+            pathname: route,
+            page: appPage,
+            filename: getFilename(AppPathsManifest[appPage]),
+            appPaths: appPages,
+        };
+    }
+    const appRoute = appPaths.find((appPath) => appPath.endsWith("/route"));
+    if (appRoute) {
+        return {
+            kind: "APP_ROUTE",
+            pathname: route,
+            page: appRoute,
+            filename: getFilename(AppPathsManifest[appRoute]),
+        };
+    }
+    if (PagesManifest[route]) {
+        return {
+            kind: route === "/api" || route.startsWith("/api/") ? "PAGES_API" : "PAGES",
+            pathname: route,
+            page: route,
+            filename: getFilename(PagesManifest[route]),
+        };
+    }
+    return undefined;
+}
+/**
+ * Resolves a manifest entry to the absolute path of the compiled server module.
+ *
+ * @param manifestPath The path relative to `.next/server`, as stored in the manifests
+ * @return The absolute module path, or an empty string when the entry is missing
+ */
+function getFilename(manifestPath) {
+    return manifestPath ? path.join(NEXT_DIR, "server", manifestPath) : "";
+}
+/**
+ * Normalizes a pathname so it can be matched against route patterns.
+ *
+ * Strips the basePath, then the locale (case-insensitive), then the trailing slash, which are not part of route
+ * patterns. The pathname is not decoded: params are decoded after matching, like Next.js.
+ *
+ * @param pathname The internal pathname of the request
+ * @return The pathname without basePath, locale prefix and trailing slash
+ */
+function normalizePathname(pathname) {
+    const basePath = NextConfig.basePath;
+    let normalized = pathname;
+    if (basePath &&
+        (normalized === basePath || normalized.startsWith(`${basePath}/`))) {
+        normalized = normalized.slice(basePath.length) || "/";
+    }
+    normalized = normalizeLocalePath(normalized, NextConfig.i18n?.locales);
+    return normalized !== "/" && normalized.endsWith("/")
+        ? normalized.slice(0, -1)
+        : normalized;
+}
+/**
+ * Extracts the decoded params of a route for a normalized pathname.
+ *
+ * Static routes have `undefined` params. Missing optional catch-all params are omitted.
+ *
+ * @param route The route pattern, i.e. `/blog/[slug]`
+ * @param pathname The normalized pathname to match against the route
+ * @return The params, `undefined` for a matching static route, or `null` when the route doesn't match
+ * @throws {URIError} If a captured parameter contains malformed percent encoding, like Next.js
+ */
+function getRouteParams(route, pathname) {
+    const dynamicRoute = RoutesManifest.routes.dynamic.find(({ page }) => page === route);
+    if (!dynamicRoute) {
+        return pathname === route ? undefined : null;
+    }
+    const result = new RegExp(dynamicRoute.regex).exec(pathname);
+    if (!result) {
+        return null;
+    }
+    // The regex has one capture group per dynamic segment, in order
+    const params = {};
+    let group = 1;
+    for (const segment of route.split("/")) {
+        const dynamicSegment = DYNAMIC_SEGMENT_REGEX.exec(segment);
+        if (!dynamicSegment) {
+            continue;
+        }
+        const [, isCatchAll, name] = dynamicSegment;
+        const value = result[group++];
+        if (value !== undefined) {
+            params[name] = isCatchAll
+                ? value.split("/").map(decodeURIComponent)
+                : decodeURIComponent(value);
+        }
+    }
+    return params;
+}

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

@@ -87,6 +87,34 @@ export interface RouteDefinition {
     page: string;
     regex: string;
 }
+/**
+ * Kind of a Next.js route.
+ * https://github.com/vercel/next.js/blob/v16.4.0/packages/next/src/server/route-kind.ts
+ */
+export type RouteKind = "PAGES" | "PAGES_API" | "APP_PAGE" | "APP_ROUTE";
+/**
+ * Subset of the Next.js route definition read when rendering a `match` request meta.
+ * Not to be confused with the routes manifest `RouteDefinition` above.
+ * https://github.com/vercel/next.js/blob/v16.4.0/packages/next/src/server/route-definitions/route-definition.ts
+ */
+export interface RouteMatchDefinition {
+    kind: RouteKind;
+    pathname: string;
+    page: string;
+    filename: string;
+    /** Only for `APP_PAGE` routes */
+    appPaths?: string[];
+}
+/**
+ * The Next.js `match` request meta, the route selected to render a request.
+ * OpenNext only passes it to Next.js 16.4+, which no longer selects the route from `invokeOutput`.
+ * https://github.com/vercel/next.js/blob/v16.4.0/packages/next/src/server/route-matches/route-match.ts
+ */
+export interface RouteMatch {
+    definition: RouteMatchDefinition;
+    /** `undefined` for static routes */
+    params?: Record<string, string | string[]>;
+}
 export interface DataRouteDefinition {
     page: string;
     dataRouteRegex: string;

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "4.1.10",
+  "version": "4.1.11",
   "bin": {
     "open-next": "./dist/index.js"
   },
@@ -56,12 +56,12 @@
     "@types/express": "5.0.6",
     "@types/node": "20.17.6",
     "concurrently": "^9.2.4",
-    "next": "16.3.8",
+    "next": "16.4.1",
     "tsc-alias": "^1.9.7",
     "typescript": "5.9.3"
   },
   "peerDependencies": {
-    "next": ">=15.5.27 <16 || >=16.3.8"
+    "next": ">=15.5.28 <16 || >=16.4.1"
   },
   "bugs": {
     "url": "https://github.com/opennextjs/opennextjs-aws/issues"