@opennextjs/aws 4.1.15 → 4.1.16

package/dist/adapters/cache.js

@@ -167,8 +167,9 @@ export default class Cache {
             const store = globalThis.__openNextAls.getStore();
             if (store) {
                 // The sentinel is kept as is in the store so that the revalidation queue keeps
-                // deduplicating every stale request for the same path.
+                // deduplicating every stale request for the same path. The queue gets the real time.
                 store.lastModified = _isStale ? 1 : _lastModified;
+                store.entryLastModified = _lastModified;
             }
             if (_isStale) {
                 _lastModified = getStaleLastModified(cacheData.revalidate);

package/dist/core/requestHandler.d.ts

@@ -2,6 +2,22 @@ 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";
+type HeaderRecord = InternalEvent["headers"];
+/**
+ * Splits the headers of a routed event into the request and response headers.
+ *
+ * The routing adds the middleware and `next.config` response headers to the event with a prefix each (see
+ * `applyResponseHeaders`). As in Next.js, both go on the response but only the middleware headers go on the request:
+ * a `Content-Security-Policy` from `next.config` must not replace the one, holding the script nonce, that the
+ * middleware set on the request.
+ *
+ * @param eventHeaders The headers of the routed event, not modified
+ * @returns The headers to send to Next.js and the headers to set on the response
+ */
+export declare function splitRoutingHeaders(eventHeaders: HeaderRecord): {
+    requestHeaders: HeaderRecord;
+    responseHeaders: HeaderRecord;
+};
 export declare function openNextHandler(internalEvent: InternalEvent, options?: OpenNextHandlerOptions): Promise<InternalResult>;
 /**
  * Renders the next resolved route after a `fallback: false` route threw a `NoFallbackError`.
@@ -26,3 +42,4 @@ export declare function openNextHandler(internalEvent: InternalEvent, options?:
  * @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>;
+export {};

package/dist/core/requestHandler.js

@@ -8,13 +8,45 @@ 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 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, NEXT_CONFIG_HEADER_PREFIX, NEXT_CONFIG_HEADER_PREFIX_LEN, } from "./routingHandler";
 import { requestHandler, setNextjsPrebundledReact } from "./util";
 // This is used to identify requests in the cache
 globalThis.__openNextAls = new AsyncLocalStorage();
 //#override patchAsyncStorage
 patchAsyncStorage();
 //#endOverride
+/**
+ * Splits the headers of a routed event into the request and response headers.
+ *
+ * The routing adds the middleware and `next.config` response headers to the event with a prefix each (see
+ * `applyResponseHeaders`). As in Next.js, both go on the response but only the middleware headers go on the request:
+ * a `Content-Security-Policy` from `next.config` must not replace the one, holding the script nonce, that the
+ * middleware set on the request.
+ *
+ * @param eventHeaders The headers of the routed event, not modified
+ * @returns The headers to send to Next.js and the headers to set on the response
+ */
+export function splitRoutingHeaders(eventHeaders) {
+    const requestHeaders = {};
+    const middlewareHeaders = {};
+    const nextConfigHeaders = {};
+    for (const [key, value] of Object.entries(eventHeaders)) {
+        if (key.startsWith(MIDDLEWARE_HEADER_PREFIX)) {
+            middlewareHeaders[key.slice(MIDDLEWARE_HEADER_PREFIX_LEN)] = value;
+        }
+        else if (key.startsWith(NEXT_CONFIG_HEADER_PREFIX)) {
+            nextConfigHeaders[key.slice(NEXT_CONFIG_HEADER_PREFIX_LEN)] = value;
+        }
+        else {
+            requestHeaders[key] = value;
+        }
+    }
+    return {
+        requestHeaders: { ...requestHeaders, ...middlewareHeaders },
+        // The routing already dropped the `next.config` headers that must not take precedence.
+        responseHeaders: { ...middlewareHeaders, ...nextConfigHeaders },
+    };
+}
 export async function openNextHandler(internalEvent, options) {
     const initialHeaders = internalEvent.headers;
     // We only use the requestId header if we are using an external middleware
@@ -60,22 +92,20 @@ export async function openNextHandler(internalEvent, options) {
             assetResolver: globalThis.assetResolver,
         });
         //#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;
-            }
-            const key = rawKey.slice(MIDDLEWARE_HEADER_PREFIX_LEN);
-            // We skip this header here since it is used by Next internally and we don't want it on the response headers.
-            // This header needs to be present in the request headers for processRequest, so cookies().get() from Next will work on initial render.
-            if (key !== "x-middleware-set-cookie") {
-                overwrittenResponseHeaders[key] = value;
-            }
-            headers[key] = value;
-            delete headers[rawKey];
+        // The headers of a result are not prefixed, they are the response headers.
+        let requestHeaders = {};
+        let overwrittenResponseHeaders = {};
+        if (!("type" in routingResult)) {
+            const split = splitRoutingHeaders(routingResult.internalEvent.headers);
+            requestHeaders = split.requestHeaders;
+            overwrittenResponseHeaders = split.responseHeaders;
+            routingResult = {
+                ...routingResult,
+                internalEvent: {
+                    ...routingResult.internalEvent,
+                    headers: requestHeaders,
+                },
+            };
         }
         if ("isExternalRewrite" in routingResult &&
             routingResult.isExternalRewrite === true) {
@@ -138,7 +168,7 @@ export async function openNextHandler(internalEvent, options) {
             // 2. We could alter the lastModified time of our cache to make next believe that the cache is fresh, but this could cause issues with stale data since the cdn will cache the stale data as if it was fresh
             // 3. OUR CHOICE: We could pass a purpose prefetch header to the serverless function to make next believe that the request is a prefetch request and not trigger revalidation (This could potentially break in the future if next changes the behavior of prefetch requests)
             headers: {
-                ...headers,
+                ...requestHeaders,
                 //#override appendPrefetch
                 purpose: "prefetch",
                 //#endOverride

package/dist/core/revalidate.js

@@ -121,6 +121,7 @@ export function createRevalidate(revalidateInProcess) {
             ? globalThis.__openNextAls.run({
                 ...store,
                 lastModified: undefined,
+                entryLastModified: undefined,
                 writtenTags: new Set(),
                 requestCache: new RequestCache(),
             }, renderInProcess)

package/dist/core/routing/cacheInterceptor.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { AppPathsManifest, NextConfig, PagesManifest, PrerenderManifest, } from "../../adapters/config/index.js";
+import { decodePathParams } from "../../utils/normalize-path.js";
 import { emptyReadableStream, toReadableStream } from "../../utils/stream.js";
 import { isBinaryContentType } from "../../utils/binary.js";
 import { getTagsFromValue, hasBeenRevalidated, isStale } from "../../utils/cache.js";
@@ -255,26 +256,6 @@ function computeStatusCode(rewriteStatusCode, cachedStatusCode) {
     }
     return rewriteStatusCode ?? cachedStatusCode ?? 200;
 }
-/**
- *
- * https://github.com/vercel/next.js/blob/34039551d2e5f611c0abde31a197d9985918adaf/packages/next/src/shared/lib/router/utils/escape-path-delimiters.ts#L2-L10
- */
-function escapePathDelimiters(segment, escapeEncoded) {
-    return segment.replace(new RegExp(`([/#?]${escapeEncoded ? "|%(2f|23|3f|5c)" : ""})`, "gi"), (char) => encodeURIComponent(char));
-}
-/**
- *
- * SSG cache key needs to be decoded, but some characters needs to be properly escaped
- * https://github.com/vercel/next.js/blob/34039551d2e5f611c0abde31a197d9985918adaf/packages/next/src/server/lib/router-utils/decode-path-params.ts#L11-L26
- * Decoding must be atomic, as in Next.js. Partially decoding a malformed path
- * could select a different cache route than the one evaluated by middleware.
- */
-function decodePathParams(pathname) {
-    return pathname
-        .split("/")
-        .map((segment) => escapePathDelimiters(decodeURIComponent(segment), true))
-        .join("/");
-}
 let routeCacheManifests;
 function getRouteCacheManifests() {
     routeCacheManifests ??= {

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

@@ -20,9 +20,12 @@ export declare function getCompiledRegExp(pattern: string, flags?: string): RegE
  * 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
  *
+ * Header names are lowercased. As Next.js applies them with the case-insensitive `res.setHeader()`, the last matching
+ * route wins when several set the same header, whatever its case.
+ *
  * @param event The request used to match configured headers
  * @param configHeaders The configured header routes
- * @returns The response headers produced by every matching route
+ * @returns The response headers produced by every matching route, keyed by lowercase name
  * @throws {SyntaxError} When a configured route pattern is invalid
  */
 export declare function getNextConfigHeaders(event: InternalEvent, configHeaders?: Header[] | undefined): Record<string, string | undefined>;
@@ -78,6 +81,16 @@ export declare function handleRewrites<T extends RewriteDefinition>(event: Inter
 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;
+/**
+ * Rewrites the event to `/404` for paths that `fallback: false` routes do not pregenerate.
+ *
+ * A path is pregenerated when its decoded form is a key of the prerender manifest routes.
+ * The rewrite only applies when no other static or dynamic route can serve the path.
+ *
+ * @param internalEvent The incoming event
+ * @param prerenderManifest The prerender manifest
+ * @returns The (possibly rewritten) event and whether the path is pregenerated
+ */
 export declare function handleFallbackFalse(internalEvent: InternalEvent, prerenderManifest?: PrerenderManifest): {
     event: InternalEvent;
     isISR: boolean;

package/dist/core/routing/matcher.js

@@ -1,6 +1,6 @@
 import { NextConfig } from "../../adapters/config/index.js";
 import { compile, match, parse } from "path-to-regexp";
-import { normalizeRepeatedSlashes } from "../../utils/normalize-path.js";
+import { decodePathParams, normalizeRepeatedSlashes, } from "../../utils/normalize-path.js";
 import { emptyReadableStream, toReadableStream } from "../../utils/stream.js";
 import { debug } from "../../adapters/logger";
 import { handleLocaleRedirect, localizePath } from "./i18n";
@@ -223,9 +223,12 @@ function compileQueryString(queryString, params) {
  * 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
  *
+ * Header names are lowercased. As Next.js applies them with the case-insensitive `res.setHeader()`, the last matching
+ * route wins when several set the same header, whatever its case.
+ *
  * @param event The request used to match configured headers
  * @param configHeaders The configured header routes
- * @returns The response headers produced by every matching route
+ * @returns The response headers produced by every matching route, keyed by lowercase name
  * @throws {SyntaxError} When a configured route pattern is invalid
  */
 export function getNextConfigHeaders(event, configHeaders) {
@@ -254,11 +257,11 @@ export function getNextConfigHeaders(event, configHeaders) {
                 try {
                     const key = hasParams ? compileNonPath(h.key, params) : h.key;
                     const value = hasParams ? compileNonPath(h.value, params) : h.value;
-                    requestHeaders[key] = value;
+                    requestHeaders[key.toLowerCase()] = value;
                 }
                 catch {
                     debug(`Error matching header ${h.key} with value ${h.value}`);
-                    requestHeaders[h.key] = h.value;
+                    requestHeaders[h.key.toLowerCase()] = h.value;
                 }
             });
         }
@@ -540,6 +543,16 @@ export function fixDataPage(internalEvent, buildId) {
     }
     return internalEvent;
 }
+/**
+ * Rewrites the event to `/404` for paths that `fallback: false` routes do not pregenerate.
+ *
+ * A path is pregenerated when its decoded form is a key of the prerender manifest routes.
+ * The rewrite only applies when no other static or dynamic route can serve the path.
+ *
+ * @param internalEvent The incoming event
+ * @param prerenderManifest The prerender manifest
+ * @returns The (possibly rewritten) event and whether the path is pregenerated
+ */
 export function handleFallbackFalse(internalEvent, prerenderManifest) {
     const { rawPath } = internalEvent;
     const { dynamicRoutes = {}, routes = {} } = prerenderManifest ?? {};
@@ -563,7 +576,14 @@ export function handleFallbackFalse(internalEvent, prerenderManifest) {
     const matchedStaticRoute = staticRouteMatcher(localizedPath);
     const prerenderedFallbackRoutesName = prerenderedFallbackRoutes.map(([name]) => name);
     const matchedDynamicRoute = dynamicRouteMatcher(localizedPath).filter(({ route }) => !prerenderedFallbackRoutesName.includes(route));
-    const isPregenerated = Object.keys(routes).includes(localizedPath);
+    let isPregenerated = false;
+    try {
+        // The prerender manifest keys routes by their decoded path while rawPath is percent-encoded.
+        isPregenerated = Object.hasOwn(routes, decodePathParams(localizedPath));
+    }
+    catch {
+        // A malformed escape sequence cannot name a prerendered route.
+    }
     if (routeFallback &&
         !isPregenerated &&
         matchedStaticRoute.length === 0 &&

package/dist/core/routing/middleware.js

@@ -101,10 +101,13 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
     let middlewareSetCookie;
     // These are internal headers used by Next.js, we don't want to expose them to the client
     // NOTE: keys must be in lowercase to match the normalized header keys.
+    // See `resolve-routes.ts` in Next.js for the headers it drops from the middleware response.
     const filteredHeaders = [
         "x-middleware-override-headers",
         "x-middleware-next",
         "x-middleware-rewrite",
+        "x-middleware-redirect",
+        "x-middleware-refresh",
         // We need to drop `content-encoding` because it will be decoded
         "content-encoding",
     ];

package/dist/core/routing/util.js

@@ -303,12 +303,20 @@ export async function revalidateIfRequired(host, rawPath, headers, req) {
         // If data has the same etag during these 5 min dedup window, it will be deduplicated and not revalidated.
         try {
             const hash = (str) => crypto.createHash("md5").update(str).digest("hex");
-            const lastModified = globalThis.__openNextAls.getStore()?.lastModified ?? 0;
+            const store = globalThis.__openNextAls.getStore();
+            // `1` when the entry is stale by tag, so that the deduplication id is the same for every copy of the entry
+            const lastModified = store?.lastModified ?? 0;
             // For some weird cases, lastModified is not set, haven't been able to figure out yet why
             // For those cases we add the etag to the deduplication id, it might help
             const eTag = `${headers.etag ?? headers.ETag ?? ""}`;
             await globalThis.queue.send({
-                MessageBody: { host, url: revalidateUrl, eTag, lastModified },
+                MessageBody: {
+                    host,
+                    url: revalidateUrl,
+                    eTag,
+                    // The time of the entry, so that the queue can skip it when it was revalidated since
+                    lastModified: store?.entryLastModified ?? lastModified,
+                },
                 MessageDeduplicationId: hash(`${rawPath}-${lastModified}-${eTag}`),
                 MessageGroupId: generateMessageGroupId(rawPath),
             });

package/dist/core/routingHandler.d.ts

@@ -3,6 +3,8 @@ import type { AssetResolver } from "../types/overrides.js";
 export declare const MIDDLEWARE_HEADER_PREFIX = "x-middleware-response-";
 export declare const MIDDLEWARE_HEADER_PREFIX_LEN: number;
 export declare const INTERNAL_HEADER_PREFIX = "x-opennext-";
+export declare const NEXT_CONFIG_HEADER_PREFIX = "x-opennext-next-config-response-";
+export declare const NEXT_CONFIG_HEADER_PREFIX_LEN: number;
 export declare const INTERNAL_HEADER_INITIAL_URL = "x-opennext-initial-url";
 export declare const INTERNAL_HEADER_LOCALE = "x-opennext-locale";
 export declare const INTERNAL_HEADER_RESOLVED_ROUTES = "x-opennext-resolved-routes";

package/dist/core/routingHandler.js

@@ -11,6 +11,8 @@ import { constructNextUrl, normalizeLocationHeader } from "./routing/util";
 export const MIDDLEWARE_HEADER_PREFIX = "x-middleware-response-";
 export const MIDDLEWARE_HEADER_PREFIX_LEN = MIDDLEWARE_HEADER_PREFIX.length;
 export const INTERNAL_HEADER_PREFIX = "x-opennext-";
+export const NEXT_CONFIG_HEADER_PREFIX = `${INTERNAL_HEADER_PREFIX}next-config-response-`;
+export const NEXT_CONFIG_HEADER_PREFIX_LEN = NEXT_CONFIG_HEADER_PREFIX.length;
 export const INTERNAL_HEADER_INITIAL_URL = `${INTERNAL_HEADER_PREFIX}initial-url`;
 export const INTERNAL_HEADER_LOCALE = `${INTERNAL_HEADER_PREFIX}locale`;
 export const INTERNAL_HEADER_RESOLVED_ROUTES = `${INTERNAL_HEADER_PREFIX}resolved-routes`;
@@ -40,24 +42,34 @@ const NEXT_INTERNAL_HEADERS = [
     "x-matched-path",
     "x-nextjs-data",
     "x-next-resume-state-length",
+    "next-resume",
 ];
 /**
- * Adds the middleware headers to an event or result.
+ * Adds the `next.config` and middleware response headers to an event or result.
  *
- * @param eventOrResult
- * @param middlewareHeaders
+ * On an event, each kind gets its own prefix so that the request handler can tell them apart (see
+ * `splitRoutingHeaders`). On a result, the headers are the response and are not prefixed.
+ *
+ * `nextConfigHeaders` take precedence over `middlewareHeaders` on the response.
+ *
+ * @param eventOrResult The event or result to add the headers to, its headers are mutated
+ * @param nextConfigHeaders The response headers from the `next.config` `headers()`
+ * @param middlewareHeaders The response headers set by the middleware
  */
-function applyMiddlewareHeaders(eventOrResult, middlewareHeaders) {
-    // Use the `MIDDLEWARE_HEADER_PREFIX` prefix for events, they will be processed by the request handler later.
-    // Results do not go through the request handler and should not be prefixed.
+function applyResponseHeaders(eventOrResult, nextConfigHeaders, middlewareHeaders) {
     const isResult = isInternalResult(eventOrResult);
     const headers = eventOrResult.headers;
-    const keyPrefix = isResult ? "" : MIDDLEWARE_HEADER_PREFIX;
-    Object.entries(middlewareHeaders).forEach(([key, value]) => {
-        if (value) {
-            headers[keyPrefix + key] = Array.isArray(value) ? value.join(",") : value;
+    const addHeaders = (source, keyPrefix) => {
+        for (const [key, value] of Object.entries(source)) {
+            if (value) {
+                headers[keyPrefix + key] = Array.isArray(value)
+                    ? value.join(",")
+                    : value;
+            }
         }
-    });
+    };
+    addHeaders(middlewareHeaders, isResult ? "" : MIDDLEWARE_HEADER_PREFIX);
+    addHeaders(nextConfigHeaders, isResult ? "" : NEXT_CONFIG_HEADER_PREFIX);
 }
 export default async function routingHandler(event, { assetResolver }) {
     try {
@@ -78,8 +90,7 @@ export default async function routingHandler(event, { assetResolver }) {
                 delete event.headers[key];
             }
         }
-        // Headers from the Next config and middleware (the later are applied further down).
-        let headers = getNextConfigHeaders(event, ConfigHeaders);
+        let nextConfigHeaders = getNextConfigHeaders(event, ConfigHeaders);
         let eventOrResult = fixDataPage(event, BuildId);
         if (isInternalResult(eventOrResult)) {
             return eventOrResult;
@@ -101,17 +112,10 @@ export default async function routingHandler(event, { assetResolver }) {
         }
         const middlewareHeadersPrioritized = globalThis.openNextConfig.dangerous
             ?.middlewareHeadersOverrideNextConfigHeaders ?? false;
+        const middlewareHeaders = middlewareEventOrResult.responseHeaders ?? {};
         if (middlewareHeadersPrioritized) {
-            headers = {
-                ...headers,
-                ...middlewareEventOrResult.responseHeaders,
-            };
-        }
-        else {
-            headers = {
-                ...middlewareEventOrResult.responseHeaders,
-                ...headers,
-            };
+            // Both are keyed by lowercase name.
+            nextConfigHeaders = Object.fromEntries(Object.entries(nextConfigHeaders).filter(([key]) => !Object.hasOwn(middlewareHeaders, key)));
         }
         let isExternalRewrite = middlewareEventOrResult.isExternalRewrite ?? false;
         eventOrResult = middlewareEventOrResult;
@@ -127,7 +131,7 @@ export default async function routingHandler(event, { assetResolver }) {
             if (!isExternalRewrite) {
                 const assetResult = await assetResolver?.maybeGetAssetResult?.(eventOrResult);
                 if (assetResult) {
-                    applyMiddlewareHeaders(assetResult, headers);
+                    applyResponseHeaders(assetResult, nextConfigHeaders, middlewareHeaders);
                     return assetResult;
                 }
             }
@@ -192,12 +196,12 @@ export default async function routingHandler(event, { assetResolver }) {
             debug("Cache interception enabled");
             eventOrResult = await cacheInterceptor(eventOrResult, resolvedRoutes);
             if (isInternalResult(eventOrResult)) {
-                applyMiddlewareHeaders(eventOrResult, headers);
+                applyResponseHeaders(eventOrResult, nextConfigHeaders, middlewareHeaders);
                 return eventOrResult;
             }
         }
-        // We apply the headers from the middleware response last
-        applyMiddlewareHeaders(eventOrResult, headers);
+        // We apply the response headers last
+        applyResponseHeaders(eventOrResult, nextConfigHeaders, middlewareHeaders);
         debug("resolvedRoutes", resolvedRoutes);
         return {
             internalEvent: eventOrResult,

package/dist/minimize-js.d.ts

@@ -1 +1,10 @@
+/**
+ * Minifies the JS (and optionally JSON) files of a directory in place.
+ *
+ * Calls can run concurrently. Failed files are logged and do not throw.
+ *
+ * @param dir Directory to walk recursively.
+ * @param opts Minification options.
+ * @return A promise that resolves once all the files have been processed.
+ */
 export declare function minifyAll(dir: any, opts: any): Promise<void>;

package/dist/minimize-js.js

@@ -4,11 +4,8 @@
 // @ts-nocheck
 import fs from "node:fs/promises";
 import path from "node:path";
-import minify from "@node-minify/core";
-import terser from "@node-minify/terser";
-const failed_files = [];
-let total_files = 0;
-const options = {};
+import { minify } from "@node-minify/core";
+import { terser } from "@node-minify/terser";
 const promiseSeries = async (tasks, initial) => {
     if (!Array.isArray(tasks)) {
         return Promise.reject(new TypeError("promise.series only accepts an array of functions"));
@@ -17,29 +14,28 @@ const promiseSeries = async (tasks, initial) => {
         return current.then(next);
     }, Promise.resolve(initial));
 };
-const minifyJS = async (file) => {
-    total_files++;
+const minifyJS = async (file, ctx) => {
     try {
         await minify({
             compressor: terser,
             input: file,
             output: file,
+            // node-minify 10 throws when the output is empty (i.e. empty or comment-only files)
+            allowEmptyOutput: true,
             options: {
-                module: options.module,
-                mangle: options.mangle,
+                module: ctx.options.module,
+                mangle: ctx.options.mangle,
                 compress: { reduce_vars: false },
             },
         });
     }
     catch (e) {
-        failed_files.push(file);
+        ctx.failed_files.push(file);
     }
-    //process.stdout.write(".");
 };
-const minifyJSON = async (file) => {
+const minifyJSON = async (file, options) => {
     try {
         if (options.compress_json || options.packagejson) {
-            total_files++;
             const is_package_json = file.indexOf("package.json") > -1;
             const data = await fs.readFile(file, "utf8");
             const json = JSON.parse(data);
@@ -63,9 +59,8 @@ const minifyJSON = async (file) => {
         }
     }
     catch (e) { }
-    //process.stdout.write(".");
 };
-const walk = async (currentDirPath) => {
+const walk = async (currentDirPath, ctx) => {
     const js_files = [];
     const json_files = [];
     const dirs = [];
@@ -77,26 +72,32 @@ const walk = async (currentDirPath) => {
         if (stat.isFile()) {
             if (filePath.substr(-5) === ".json")
                 json_files.push(filePath);
-            else if (filePath.substr(-3) === ".js" || options.all_js)
+            else if (filePath.substr(-3) === ".js" || ctx.options.all_js)
                 js_files.push(filePath);
         }
         else if (stat.isDirectory() && !is_bin.test(filePath)) {
             dirs.push(filePath);
         }
     }
-    const js_promise = Promise.all(js_files.map((f) => minifyJS(f)));
-    const json_promise = Promise.all(json_files.map((f) => minifyJSON(f)));
+    const js_promise = Promise.all(js_files.map((f) => minifyJS(f, ctx)));
+    const json_promise = Promise.all(json_files.map((f) => minifyJSON(f, ctx.options)));
     await Promise.all([js_promise, json_promise]);
-    await promiseSeries(dirs.map((dir) => () => walk(dir)));
+    await promiseSeries(dirs.map((dir) => () => walk(dir, ctx)));
 };
+/**
+ * Minifies the JS (and optionally JSON) files of a directory in place.
+ *
+ * Calls can run concurrently. Failed files are logged and do not throw.
+ *
+ * @param dir Directory to walk recursively.
+ * @param opts Minification options.
+ * @return A promise that resolves once all the files have been processed.
+ */
 export async function minifyAll(dir, opts) {
-    Object.assign(options, opts || {});
-    //console.log("minify-all-js options:\n", JSON.stringify(options, null, 2));
-    await walk(dir);
-    //process.stdout.write(".\n");
-    //console.log("Total found files: " + total_files);
-    if (failed_files.length) {
+    const ctx = { options: { ...opts }, failed_files: [] };
+    await walk(dir, ctx);
+    if (ctx.failed_files.length) {
         console.log("\n\nFailed to minify files:");
-        failed_files.forEach((f) => console.log(`\t${f}`));
+        ctx.failed_files.forEach((f) => console.log(`\t${f}`));
     }
 }

package/dist/types/global.d.ts

@@ -52,7 +52,19 @@ interface OpenNextRequestContext {
     pendingPromiseRunner: DetachedPromiseRunner;
     isISRRevalidation?: boolean;
     mergeHeadersPriority?: "middleware" | "handler";
+    /**
+     * Last modified time of the page (used in main functions, only available for ISR/SSG).
+     *
+     * `1` when the entry is stale by tag, so that the revalidation queue deduplicates every stale
+     * request for the same path. See `entryLastModified` for the time of the entry.
+     */
     lastModified?: number;
+    /**
+     * Last modified time of the cache entry, also when it is stale by tag (`lastModified` is then `1`).
+     *
+     * Sent to the revalidation queue in `MessageBody.lastModified`.
+     */
+    entryLastModified?: number;
     waitUntil?: WaitUntil;
     /** We use this to deduplicate write of the tags*/
     writtenTags: Set<string>;

package/dist/utils/normalize-path.d.ts

@@ -1,3 +1,18 @@
 export declare function normalizePath(path: string): string;
 export declare function normalizeRepeatedSlashes(url: URL): string;
+/**
+ * Decodes a pathname the way Next.js does to key prerendered routes.
+ *
+ * Each segment is decoded while path delimiters (e.g. `%2F`) stay encoded,
+ * so that an encoded delimiter does not split a segment.
+ * Decoding must be atomic, as in Next.js: partially decoding a malformed path
+ * could select a different route than the one Next.js would select.
+ *
+ * See: https://github.com/vercel/next.js/blob/3403955/packages/next/src/server/lib/router-utils/decode-path-params.ts#L11-L26
+ *
+ * @param pathname The percent-encoded pathname
+ * @returns The decoded pathname
+ * @throws {URIError} When the pathname contains a malformed escape sequence
+ */
+export declare function decodePathParams(pathname: string): string;
 export declare function getMonorepoRelativePath(relativePath?: string): string;

package/dist/utils/normalize-path.js

@@ -9,6 +9,38 @@ export function normalizeRepeatedSlashes(url) {
         .replace(/\\/g, "/")
         .replace(/\/\/+/g, "/")}${url.search}`;
 }
+/**
+ * Percent-encodes the path delimiters of a decoded path segment.
+ *
+ * See: https://github.com/vercel/next.js/blob/3403955/packages/next/src/shared/lib/router/utils/escape-path-delimiters.ts#L2-L10
+ *
+ * @param segment The decoded path segment
+ * @param escapeEncoded Whether to also escape already encoded delimiters (e.g. `%2F`)
+ * @returns The segment with its delimiters encoded
+ */
+function escapePathDelimiters(segment, escapeEncoded) {
+    return segment.replace(new RegExp(`([/#?]${escapeEncoded ? "|%(2f|23|3f|5c)" : ""})`, "gi"), (char) => encodeURIComponent(char));
+}
+/**
+ * Decodes a pathname the way Next.js does to key prerendered routes.
+ *
+ * Each segment is decoded while path delimiters (e.g. `%2F`) stay encoded,
+ * so that an encoded delimiter does not split a segment.
+ * Decoding must be atomic, as in Next.js: partially decoding a malformed path
+ * could select a different route than the one Next.js would select.
+ *
+ * See: https://github.com/vercel/next.js/blob/3403955/packages/next/src/server/lib/router-utils/decode-path-params.ts#L11-L26
+ *
+ * @param pathname The percent-encoded pathname
+ * @returns The decoded pathname
+ * @throws {URIError} When the pathname contains a malformed escape sequence
+ */
+export function decodePathParams(pathname) {
+    return pathname
+        .split("/")
+        .map((segment) => escapePathDelimiters(decodeURIComponent(segment), true))
+        .join("/");
+}
 export function getMonorepoRelativePath(relativePath = "../..") {
     return path.join(globalThis.monorepoPackagePath
         .split("/")

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "4.1.15",
+  "version": "4.1.16",
   "bin": {
     "open-next": "./dist/index.js"
   },
@@ -39,8 +39,8 @@
     "@aws-sdk/client-lambda": "3.984.0",
     "@aws-sdk/client-s3": "3.984.0",
     "@aws-sdk/client-sqs": "3.984.0",
-    "@node-minify/core": "^9.0.2",
-    "@node-minify/terser": "^9.0.1",
+    "@node-minify/core": "^10.5.0",
+    "@node-minify/terser": "^10.5.0",
     "@tsconfig/node18": "^18.2.7",
     "aws4fetch": "^1.0.20",
     "chalk": "^5.6.2",