@opennextjs/aws 4.0.3 → 4.1.1

package/dist/adapters/cache.js

@@ -1,4 +1,4 @@
-import { getTagsFromValue, hasBeenRevalidated, isStale, writeTags, } from "../utils/cache";
+import { getStaleLastModified, getTagsFromValue, hasBeenRevalidated, isStale, writeTags, } from "../utils/cache";
 import { isBinaryContentType } from "../utils/binary";
 import { compareSemver } from "../utils/semver";
 import { debug, error, warn } from "./logger";
@@ -92,8 +92,12 @@ export default class Cache {
                 : await isStale(key, tags, _lastModified);
             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.
                 store.lastModified = _isStale ? 1 : _lastModified;
-                _lastModified = store.lastModified;
+            }
+            if (_isStale) {
+                _lastModified = getStaleLastModified(cacheData.revalidate);
             }
             if (cacheData?.type === "route") {
                 return {
@@ -111,6 +115,16 @@ export default class Cache {
                 };
             }
             if (cacheData?.type === "page" || cacheData?.type === "app") {
+                // Without the html there is no valid value to return, so we report a miss and let
+                // the server render the page. Next.js behaves the same way, its file system cache
+                // reads the `.html` file first and turns a read failure into a miss.
+                //
+                // The check is on `undefined` and not on falsiness because an empty string is a
+                // valid value: a PPR route with an empty static shell has an empty `.html` file.
+                if (cacheData.html === undefined) {
+                    warn("No html in the cache entry", key);
+                    return null;
+                }
                 if (compareSemver(globalThis.nextVersion, ">=", "15.0.0") &&
                     cacheData?.type === "app") {
                     const segmentData = new Map();
@@ -124,7 +138,13 @@ export default class Cache {
                         value: {
                             kind: "APP_PAGE",
                             html: cacheData.html,
-                            rscData: Buffer.from(cacheData.rsc),
+                            // `rsc` is absent when the build collected neither a `.rsc` nor a
+                            // `.prefetch.rsc` file, see `CachedFile`. An undefined value is expected: the
+                            // Next.js file system cache also leaves `rscData` undefined for fallback
+                            // shells, and on 16.2+ for postponed PPR routes.
+                            rscData: cacheData.rsc === undefined
+                                ? undefined
+                                : Buffer.from(cacheData.rsc),
                             status: meta?.status,
                             headers: meta?.headers,
                             postponed: meta?.postponed,
@@ -132,6 +152,13 @@ export default class Cache {
                         },
                     };
                 }
+                const pageData = cacheData.type === "page" ? cacheData.json : cacheData.rsc;
+                // Only reachable for an app page on Next.js < 15, where an absent `rsc` leaves us
+                // without any page data to return.
+                if (pageData === undefined) {
+                    warn("No page data in the cache entry", key);
+                    return null;
+                }
                 return {
                     lastModified: _lastModified,
                     value: {
@@ -139,7 +166,7 @@ export default class Cache {
                             ? "PAGES"
                             : "PAGE",
                         html: cacheData.html,
-                        pageData: cacheData.type === "page" ? cacheData.json : cacheData.rsc,
+                        pageData,
                         status: meta?.status,
                         headers: meta?.headers,
                     },
@@ -232,7 +259,7 @@ export default class Cache {
                         await globalThis.incrementalCache.set(key, {
                             type: "app",
                             html,
-                            rsc: rscData.toString("utf8"),
+                            rsc: rscData?.toString("utf8"),
                             meta: {
                                 status,
                                 headers,
@@ -408,11 +435,18 @@ export default class Cache {
         }
         // Write derivedTags to the tag cache
         // If we use an in house version of getDerivedTags in build we should use it here instead of next's one
+        // `x-next-cache-tags` is always a comma separated string: Next.js sets it from
+        // `metadata.fetchTags`, which is a string. The header type allows an array because it
+        // is shared with headers that can legitimately repeat, so we narrow on `typeof` here.
+        // Next.js guards the same way when it reads the header back.
+        const pageCacheTags = data?.kind === "PAGE" || data?.kind === "APP_PAGE"
+            ? data.headers?.["x-next-cache-tags"]
+            : undefined;
         const derivedTags = data?.kind === "FETCH"
             ? //@ts-expect-error - On older versions of next, ctx was a number, but for these cases we use data?.data?.tags
                 (ctx?.tags ?? data?.data?.tags ?? []) // before version 14 next.js used data?.data?.tags so we keep it for backward compatibility
-            : data?.kind === "PAGE"
-                ? (data.headers?.["x-next-cache-tags"]?.split(",") ?? [])
+            : typeof pageCacheTags === "string"
+                ? pageCacheTags.split(",")
                 : [];
         debug("derivedTags", derivedTags);
         // Get all tags stored in dynamodb for the given key

package/dist/build/copyTracedFiles.js

@@ -159,6 +159,15 @@ File ${serverPath} does not exist
     if (existsSync(path.join(dotNextDir, INSTRUMENTATION_TRACE_FILE))) {
         // We still need to copy the nft.json file so that computeCopyFilesForPage doesn't throw
         copyFileAndMakeOwnerWritable(path.join(dotNextDir, INSTRUMENTATION_TRACE_FILE), path.join(standaloneNextDir, INSTRUMENTATION_TRACE_FILE));
+        // Next 16's standalone output no longer includes `server/instrumentation.js`
+        // in the standalone dir, but `computeCopyFilesForPage` asserts it exists
+        // there. Copy it from the build dir (mirroring the .nft.json copy above) so
+        // the assertion passes and the instrumentation file ships in the bundle.
+        const instrumentationServerFile = path.join("server", "instrumentation.js");
+        if (existsSync(path.join(dotNextDir, instrumentationServerFile)) &&
+            !existsSync(path.join(standaloneNextDir, instrumentationServerFile))) {
+            copyFileAndMakeOwnerWritable(path.join(dotNextDir, instrumentationServerFile), path.join(standaloneNextDir, instrumentationServerFile));
+        }
         computeCopyFilesForPage("instrumentation");
         logger.debug("Adding instrumentation trace files");
     }

package/dist/build/createAssets.js

@@ -94,6 +94,13 @@ export function createCacheAssets(options) {
                 case ".json":
                 case ".body":
                 case ".rsc": {
+                    // Stripping `.prefetch` maps both `<page>.rsc` and `<page>.prefetch.rsc` onto
+                    // the same cache entry, so the `rsc` field can hold either payload. When both
+                    // files exist the first one traversed wins, as the spread below keeps the value
+                    // already recorded for that extension.
+                    //
+                    // Next 16.1 removed `.prefetch.rsc`, so the strip is a no-op on Next 16 where
+                    // the `rsc` field always holds a full payload.
                     const newFilePath = path
                         .join(outputCachePath, relativePath)
                         .substring(0, path.join(outputCachePath, relativePath).length - ext.length)

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.32.6";
+    const sharpVersion = process.env.SHARP_VERSION ?? "0.35.3";
     // 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/generateOutput.js

@@ -8,7 +8,8 @@ async function canStream(opts) {
         return false;
     }
     if (typeof opts.override.wrapper === "string") {
-        return opts.override.wrapper === "aws-lambda-streaming";
+        return (opts.override.wrapper === "aws-lambda-streaming" ||
+            opts.override.wrapper === "aws-apigw-streaming");
     }
     const wrapper = await opts.override.wrapper();
     return wrapper.supportStreaming;

package/dist/build/validateConfig.js

@@ -8,6 +8,7 @@ const compatibilityMatrix = {
     ],
     "aws-lambda-compressed": ["aws-apigw-v2"],
     "aws-lambda-streaming": ["aws-apigw-v2"],
+    "aws-apigw-streaming": ["aws-apigw-v1", "aws-apigw-v2"],
     cloudflare: ["edge"],
     "cloudflare-edge": ["edge"],
     "cloudflare-node": ["edge"],

package/dist/core/edgeFunctionHandler.js

@@ -2,7 +2,22 @@
 export default async function edgeFunctionHandler(request) {
     const path = new URL(request.url).pathname;
     const routes = globalThis._ROUTES;
-    const correspondingRoute = routes.find((route) => route.regex.some((r) => new RegExp(r).test(path)));
+    let decodedPath;
+    try {
+        // Decode the complete pathname atomically so a malformed escape cannot be
+        // partially decoded.
+        decodedPath = decodeURIComponent(path);
+    }
+    catch {
+        // A malformed pathname cannot provide a decoded route to match.
+    }
+    // Also match against the decoded pathname, while keeping the encoded URL in
+    // the request passed to middleware.
+    const correspondingRoute = routes.find((route) => route.regex.some((r) => {
+        const regex = new RegExp(r);
+        return (regex.test(path) ||
+            (decodedPath !== undefined && regex.test(decodedPath)));
+    }));
     if (!correspondingRoute) {
         throw new Error(`No route found for ${request.url}`);
     }

package/dist/core/routing/cacheInterceptor.js

@@ -3,7 +3,7 @@ import { NextConfig, PrerenderManifest } from "../../adapters/config/index";
 import { emptyReadableStream, toReadableStream } from "../../utils/stream";
 import { isBinaryContentType } from "../../utils/binary";
 import { getTagsFromValue, hasBeenRevalidated, isStale } from "../../utils/cache";
-import { debug, error } from "../../adapters/logger";
+import { debug } from "../../adapters/logger";
 import { localizePath } from "./i18n";
 import { generateMessageGroupId } from "./queue";
 const CACHE_ONE_YEAR = 60 * 60 * 24 * 365;
@@ -88,42 +88,65 @@ async function computeCacheControl(path, body, host, revalidate, lastModified, i
         etag,
     };
 }
+/**
+ * Computes the body of an RSC response from a cached app router entry.
+ *
+ * @param event The incoming event, used to read the segment prefetch header
+ * @param cachedValue The cache entry, must be of type `app`
+ * @returns The body and the headers to add to the response, or `undefined` when
+ * the entry can not serve the request - the caller should then fallback to the server.
+ * @throws When `cachedValue` is not of type `app`
+ */
 function getBodyForAppRouter(event, cachedValue) {
     if (cachedValue.type !== "app") {
         throw new Error("getBodyForAppRouter called with non-app cache value");
     }
-    try {
-        const segmentHeader = `${event.headers[NEXT_SEGMENT_PREFETCH_HEADER]}`;
-        const isSegmentResponse = Boolean(segmentHeader) &&
-            segmentHeader in (cachedValue.segmentData || {}) &&
-            !NextConfig.experimental?.prefetchInlining;
-        const body = isSegmentResponse
-            ? cachedValue.segmentData[segmentHeader]
-            : cachedValue.rsc;
+    const segmentHeader = `${event.headers[NEXT_SEGMENT_PREFETCH_HEADER]}`;
+    const isSegmentResponse = Boolean(segmentHeader) &&
+        segmentHeader in (cachedValue.segmentData || {}) &&
+        !NextConfig.experimental?.prefetchInlining;
+    if (isSegmentResponse) {
         return {
-            body,
-            additionalHeaders: isSegmentResponse
-                ? { [NEXT_PRERENDER_HEADER]: "1", [NEXT_POSTPONED_HEADER]: "2" }
-                : {},
+            body: cachedValue.segmentData[segmentHeader],
+            additionalHeaders: {
+                [NEXT_PRERENDER_HEADER]: "1",
+                [NEXT_POSTPONED_HEADER]: "2",
+            },
         };
     }
-    catch (e) {
-        error("Error while getting body for app router from cache:", e);
-        return { body: cachedValue.rsc, additionalHeaders: {} };
+    // `rsc` is absent when the build collected neither a `.rsc` nor a `.prefetch.rsc` file for
+    // this entry - fallback shells, and postponed PPR routes on Next 16.2+, see `CachedFile`.
+    // There is nothing valid to serve, and falling back to an empty payload would break the
+    // router and let the CDN cache the empty response, so let the server generate it.
+    if (cachedValue.rsc === undefined) {
+        return undefined;
     }
+    return { body: cachedValue.rsc, additionalHeaders: {} };
 }
+/**
+ * Generates the response to serve for a cached `app` or `page` entry.
+ *
+ * @param event The incoming event
+ * @param localizedPath The localized path, used to compute the cache control
+ * @param cachedValue The cache entry, must be of type `app` or `page`
+ * @param lastModified Time of the last update to the cache entry
+ * @param isStaleFromTagCache Whether the tag cache reported the entry as stale
+ * @returns The result to serve, or `undefined` when the entry can not serve the
+ * request - the caller should then fallback to the server.
+ * @throws When `cachedValue` is neither of type `app` nor `page`
+ */
 async function generateResult(event, localizedPath, cachedValue, lastModified, isStaleFromTagCache = false) {
     debug("Returning result from experimental cache");
-    let body = "";
+    let body;
     let type = "application/octet-stream";
     let isDataRequest = false;
     let additionalHeaders = {};
     if (cachedValue.type === "app") {
         isDataRequest = event.headers.rsc === "1";
         if (isDataRequest) {
-            const { body: appRouterBody, additionalHeaders: appHeaders } = getBodyForAppRouter(event, cachedValue);
-            body = appRouterBody;
-            additionalHeaders = appHeaders;
+            const appRouterResult = getBodyForAppRouter(event, cachedValue);
+            body = appRouterResult?.body;
+            additionalHeaders = appRouterResult?.additionalHeaders ?? {};
         }
         else {
             body = cachedValue.html;
@@ -138,6 +161,12 @@ async function generateResult(event, localizedPath, cachedValue, lastModified, i
     else {
         throw new Error("generateResult called with unsupported cache value type, only 'app' and 'page' are supported");
     }
+    // Next.js does not write every file for every route at build time, so the entry might
+    // not hold the data needed to serve this particular request.
+    if (body === undefined) {
+        debug("Missing body in the cache entry, falling back to the server");
+        return undefined;
+    }
     const cacheControl = await computeCacheControl(localizedPath, body, event.headers.host, cachedValue.revalidate, lastModified, isStaleFromTagCache);
     return {
         type: "core",
@@ -169,19 +198,13 @@ function escapePathDelimiters(segment, escapeEncoded) {
  *
  * 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) => {
-        try {
-            return escapePathDelimiters(decodeURIComponent(segment), true);
-        }
-        catch (e) {
-            // If decodeURIComponent fails, we return the original segment
-            return segment;
-        }
-    })
+        .map((segment) => escapePathDelimiters(decodeURIComponent(segment), true))
         .join("/");
 }
 export async function cacheInterceptor(event) {
@@ -205,14 +228,24 @@ export async function cacheInterceptor(event) {
     // We also need to remove trailing slash
     localizedPath = localizedPath.replace(/\/$/, "");
     // Then we decode the path params
-    localizedPath = decodePathParams(localizedPath);
+    try {
+        localizedPath = decodePathParams(localizedPath) || "/";
+    }
+    catch {
+        // Next.js rejects malformed path params. Do not let cache interception
+        // partially decode the path and select a different route identity.
+        return event;
+    }
+    // The route is keyed as `/` in the prerender manifest, but the generated
+    // cache asset for the app index route is uploaded as `/index`.
+    const cacheKey = localizedPath === "/" ? "/index" : localizedPath;
     debug("Checking cache for", localizedPath, PrerenderManifest);
-    const isISR = Object.keys(PrerenderManifest?.routes ?? {}).includes(localizedPath ?? "/") ||
+    const isISR = Object.keys(PrerenderManifest?.routes ?? {}).includes(localizedPath) ||
         Object.values(PrerenderManifest?.dynamicRoutes ?? {}).some((dr) => new RegExp(dr.routeRegex).test(localizedPath));
     debug("isISR", isISR);
     if (isISR) {
         try {
-            const cachedData = await globalThis.incrementalCache.get(localizedPath ?? "/index");
+            const cachedData = await globalThis.incrementalCache.get(cacheKey);
             debug("cached data in interceptor", cachedData);
             if (!cachedData?.value) {
                 return event;
@@ -223,7 +256,7 @@ export async function cacheInterceptor(event) {
                 cachedData.value?.type === "route") {
                 const _hasBeenRevalidated = cachedData.shouldBypassTagCache
                     ? false
-                    : await hasBeenRevalidated(localizedPath, tags, cachedData);
+                    : await hasBeenRevalidated(cacheKey, tags, cachedData);
                 if (_hasBeenRevalidated) {
                     return event;
                 }
@@ -231,12 +264,15 @@ export async function cacheInterceptor(event) {
             // Check if the cache entry is stale (valid but needs background revalidation)
             const _isStale = cachedData.shouldBypassTagCache
                 ? false
-                : await isStale(localizedPath, tags, cachedData.lastModified ?? Date.now());
+                : await isStale(cacheKey, tags, cachedData.lastModified ?? Date.now());
             const host = event.headers.host;
             switch (cachedData?.value?.type) {
                 case "app":
-                case "page":
-                    return generateResult(event, localizedPath, cachedData.value, cachedData.lastModified, _isStale);
+                case "page": {
+                    const result = await generateResult(event, localizedPath, cachedData.value, cachedData.lastModified, _isStale);
+                    // The cache entry can not serve this request, fallback to the server.
+                    return result ?? event;
+                }
                 case "redirect": {
                     const cacheControl = await computeCacheControl(localizedPath, "", host, cachedData.value.revalidate, cachedData.lastModified, _isStale);
                     return {

package/dist/core/routing/middleware.js

@@ -29,7 +29,17 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
         return internalEvent;
     // We only need the normalizedPath to check if the middleware should run
     const normalizedPath = localizePath(internalEvent);
-    const hasMatch = middleMatch.some((r) => r.test(normalizedPath));
+    let decodedPath;
+    try {
+        decodedPath = decodeURIComponent(normalizedPath);
+    }
+    catch {
+        // An invalid encoding cannot provide a decoded pathname to match.
+    }
+    // Next.js also tries the decoded pathname for matching, while preserving the
+    // encoded pathname in the request passed to middleware.
+    const hasMatch = middleMatch.some((r) => r.test(normalizedPath) ||
+        (decodedPath !== undefined && r.test(decodedPath)));
     if (!hasMatch)
         return internalEvent;
     const initialUrl = new URL(normalizedPath, internalEvent.url);

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

@@ -11,6 +11,16 @@ import { ReadableStream } from "node:stream/web";
 export declare function isExternal(url?: string, host?: string): boolean;
 export declare function convertFromQueryString(query: string): Record<string, string | string[]>;
 /**
+ * Splits an URL into its parts
+ *
+ * The URL is a route destination, i.e. a `path-to-regexp` pattern rather than a
+ * well formed URL, so it can not be parsed with `new URL()` which would percent
+ * encode some of the pattern characters.
+ *
+ * @param url The URL to split
+ * @param isExternal Whether the URL points to an external host
+ * @returns The protocol, hostname, pathname and query string of the URL
+ * @throws When `isExternal` is true and the URL is not an absolute HTTP(S) URL
  *
  * @__PURE__
  */

package/dist/core/routing/util.js

@@ -40,6 +40,16 @@ export function convertFromQueryString(query) {
     }));
 }
 /**
+ * Splits an URL into its parts
+ *
+ * The URL is a route destination, i.e. a `path-to-regexp` pattern rather than a
+ * well formed URL, so it can not be parsed with `new URL()` which would percent
+ * encode some of the pattern characters.
+ *
+ * @param url The URL to split
+ * @param isExternal Whether the URL points to an external host
+ * @returns The protocol, hostname, pathname and query string of the URL
+ * @throws When `isExternal` is true and the URL is not an absolute HTTP(S) URL
  *
  * @__PURE__
  */
@@ -49,12 +59,12 @@ export function getUrlParts(url, isExternal) {
         const match = url.match(regex);
         return {
             hostname: "",
-            pathname: match?.[1] ? `/${match[1]}` : url,
+            pathname: url.startsWith("/") ? `/${match?.[1] ?? ""}` : "",
             protocol: "",
             queryString: match?.[2] ?? "",
         };
     }
-    const regex = /^(https?:)\/\/?([^\/\s]+)(\/[^?]*)?(\?.*)?/;
+    const regex = /^(https?:)\/\/?([^\/\s?]+)(\/[^?]*)?(\?.*)?/;
     const match = url.match(regex);
     if (!match) {
         throw new Error(`Invalid external URL: ${url}`);

package/dist/overrides/wrappers/aws-apigw-streaming.d.ts

@@ -0,0 +1,7 @@
+import type { WrapperHandler } from "../../types/overrides";
+declare const _default: {
+    wrapper: WrapperHandler;
+    name: string;
+    supportStreaming: true;
+};
+export default _default;

package/dist/overrides/wrappers/aws-apigw-streaming.js

@@ -0,0 +1,74 @@
+import { Readable } from "node:stream";
+import { debug } from "../../adapters/logger";
+function formatWarmerResponse(event) {
+    const result = new Promise((resolve) => {
+        setTimeout(() => {
+            resolve({ serverId, type: "warmer" });
+        }, event.delay);
+    });
+    return result;
+}
+/**
+ * Streaming wrapper for an API Gateway proxy integration in
+ * `ResponseTransferMode: STREAM`.
+ *
+ * Differs from `aws-lambda-streaming` (the Lambda **Function URL** wrapper) in
+ * two ways, both mandated by API Gateway response streaming
+ * (https://aws.amazon.com/blogs/compute/building-responsive-apis-with-amazon-api-gateway-response-streaming/):
+ *
+ *  1. It does NOT set the
+ *     `application/vnd.awslambda.http-integration-response` content type. That
+ *     marker is Function-URL-specific metadata; API Gateway forwards it onto
+ *     the wire, corrupting HTTP framing.
+ *  2. It does NOT compress the response. API Gateway streaming explicitly does
+ *     not support content encoding, so the body is always emitted as
+ *     `identity`. Compression, if desired, is handled by the CDN in front
+ *     (e.g. CloudFront).
+ *
+ * The response framing itself — a JSON metadata prelude followed by an
+ * 8-null-byte delimiter, then the payload — is identical to the Function URL
+ * format and is what API Gateway expects in STREAM mode.
+ */
+const handler = async (handler, converter) => awslambda.streamifyResponse(async (event, responseStream, context) => {
+    context.callbackWaitsForEmptyEventLoop = false;
+    if ("type" in event) {
+        const result = await formatWarmerResponse(event);
+        responseStream.end(Buffer.from(JSON.stringify(result)), "utf-8");
+        await globalThis.__next_route_preloader("warmerEvent");
+        return;
+    }
+    const internalEvent = await converter.convertFrom(event);
+    responseStream.on("error", (err) => {
+        debug(err);
+        responseStream.end();
+    });
+    const streamCreator = {
+        writeHeaders: (_prelude) => {
+            // No content-encoding header — API Gateway streaming does not
+            // support content encoding; the body is emitted as identity.
+            _prelude.headers["content-encoding"] = "identity";
+            const prelude = JSON.stringify(_prelude);
+            responseStream.write(prelude);
+            // 8-null-byte delimiter separating the JSON metadata prelude from
+            // the response payload. Same framing API Gateway STREAM expects.
+            responseStream.write(new Uint8Array(8));
+            return responseStream;
+        },
+    };
+    const response = await handler(internalEvent, { streamCreator });
+    const isUsingEdge = globalThis.isEdgeRuntime ?? false;
+    if (isUsingEdge) {
+        debug("Headers has not been set, we must be in the edge runtime");
+        const stream = streamCreator.writeHeaders({
+            statusCode: response.statusCode,
+            headers: response.headers,
+            cookies: [],
+        });
+        Readable.fromWeb(response.body).pipe(stream);
+    }
+});
+export default {
+    wrapper: handler,
+    name: "aws-apigw-streaming",
+    supportStreaming: true,
+};

package/dist/types/cache.d.ts

@@ -40,7 +40,7 @@ interface IncrementalCachedPageValue {
 interface IncrementalCachedAppPageValue {
     kind: "APP_PAGE";
     html: string;
-    rscData: Buffer;
+    rscData: Buffer | undefined;
     headers?: Record<string, undefined | string | string[]>;
     postponed?: string;
     status?: number;

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

@@ -96,7 +96,7 @@ export interface Origin {
     port?: number;
     customHeaders?: Record<string, string>;
 }
-export type IncludedWrapper = "aws-lambda" | "aws-lambda-streaming" | "aws-lambda-compressed" | "node" | "cloudflare" | "cloudflare-edge" | "cloudflare-node" | "express-dev" | "dummy";
+export type IncludedWrapper = "aws-lambda" | "aws-lambda-streaming" | "aws-apigw-streaming" | "aws-lambda-compressed" | "node" | "cloudflare" | "cloudflare-edge" | "cloudflare-node" | "express-dev" | "dummy";
 export type IncludedConverter = "aws-apigw-v2" | "aws-apigw-v1" | "aws-cloudfront" | "edge" | "node" | "sqs-revalidate" | "dummy";
 export type RouteType = "route" | "page" | "app";
 export interface ResolvedRoute {

package/dist/types/overrides.d.ts

@@ -34,13 +34,35 @@ export type CachedFile = {
     meta?: Meta;
 } | {
     type: "page";
-    html: string;
+    /** Absent when the build did not collect an `.html` file for this entry. */
+    html?: string;
     json: Object;
     meta?: Meta;
 } | {
     type: "app";
-    html: string;
-    rsc: string;
+    /**
+     * The prerendered HTML.
+     *
+     * Absent when the build did not collect an `.html` file for this entry. Note that
+     * Next.js writes the `.html` unconditionally when it prerenders an app page, so this
+     * is only expected to be absent for a malformed build output. A PPR route with an
+     * empty static shell is *not* one of those cases: the file is written, empty.
+     */
+    html?: string;
+    /**
+     * The RSC payload.
+     *
+     * Both `<page>.rsc` and `<page>.prefetch.rsc` are stored here, see `createAssets`.
+     *
+     * Absent when the build emitted neither file, which depends on the Next.js version:
+     * - `15.x`: only for fallback shells. A PPR route emits a `.prefetch.rsc` in place of
+     *   its `.rsc`, so the field is set but holds the *prefetch* payload, which this type
+     *   can not distinguish from a full one.
+     * - `>= 16.2`: `.prefetch.rsc` no longer exists and a PPR route only emits a `.rsc`
+     *   when it is fully static, so the field is absent for postponed PPR routes and for
+     *   fallback shells, and holds a full payload otherwise.
+     */
+    rsc?: string;
     meta?: Meta;
     segmentData?: Record<string, string>;
 } | {

package/dist/utils/cache.d.ts

@@ -9,6 +9,21 @@ import type { CacheValue, NextModeTagCacheWriteInput, OriginalTagCacheWriteInput
  * In this case, the cache entry is still valid and can be served, but it should trigger a background revalidation to update the cache.
  */
 export declare function isStale(key: string, tags: string[], lastModified?: number): Promise<boolean>;
+/**
+ * Next.js has no explicit way for a cache handler to report an entry as stale,
+ * the only lever we have is the `lastModified` we hand back to the incremental cache.
+ *
+ * Up to Next 16.2 we return `1` (i.e. right after the epoch), which is enough for Next to
+ * compute `revalidateAfter` in the past and mark the entry as stale.
+ * Starting with Next 16.3 the incremental cache also compares `lastModified + expire` to now, and
+ * forces a blocking revalidation (`isStale === -1`, surfacing as `x-nextjs-cache: REVALIDATED`)
+ * when that is in the past. An epoch based value always trips that check, so from that version on
+ * we go back just far enough for the entry to be stale while remaining inside its expire window.
+ *
+ * @param revalidate The revalidate value stored alongside the cache entry, in seconds
+ * @returns The `lastModified` to report to Next.js for a stale entry
+ */
+export declare function getStaleLastModified(revalidate?: number | false): number;
 /**
  * @param key The key for that specific cache entry
  * @param tags Array of tags associated with that cache entry

package/dist/utils/cache.js

@@ -24,6 +24,34 @@ export async function isStale(key, tags, lastModified) {
     }
     return (await globalThis.tagCache.isStale?.(key, lastModified)) ?? false;
 }
+/**
+ * Next.js has no explicit way for a cache handler to report an entry as stale,
+ * the only lever we have is the `lastModified` we hand back to the incremental cache.
+ *
+ * Up to Next 16.2 we return `1` (i.e. right after the epoch), which is enough for Next to
+ * compute `revalidateAfter` in the past and mark the entry as stale.
+ * Starting with Next 16.3 the incremental cache also compares `lastModified + expire` to now, and
+ * forces a blocking revalidation (`isStale === -1`, surfacing as `x-nextjs-cache: REVALIDATED`)
+ * when that is in the past. An epoch based value always trips that check, so from that version on
+ * we go back just far enough for the entry to be stale while remaining inside its expire window.
+ *
+ * @param revalidate The revalidate value stored alongside the cache entry, in seconds
+ * @returns The `lastModified` to report to Next.js for a stale entry
+ */
+export function getStaleLastModified(revalidate) {
+    // The `expire` check only exists from Next 16.3, before that the sentinel is what Next expects.
+    if (!compareSemver(globalThis.nextVersion, ">=", "16.3.0")) {
+        return 1;
+    }
+    if (typeof revalidate !== "number") {
+        // Without a revalidate value Next cannot derive an expire time either,
+        // so the historical sentinel is still safe here.
+        return 1;
+    }
+    // 1ms past the revalidate window. `expire` is always >= `revalidate`, so the entry is
+    // stale without being expired (when both are equal, being expired is the correct outcome).
+    return Date.now() - revalidate * 1000 - 1;
+}
 /**
  * @param key The key for that specific cache entry
  * @param tags Array of tags associated with that cache entry

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "4.0.3",
+  "version": "4.1.1",
   "bin": {
     "open-next": "./dist/index.js"
   },
@@ -56,11 +56,12 @@
     "@types/express": "5.0.0",
     "@types/node": "20.17.6",
     "concurrently": "^9.2.1",
+    "next": "16.3.3",
     "tsc-alias": "^1.8.16",
     "typescript": "5.9.3"
   },
   "peerDependencies": {
-    "next": ">=15.5.18 <16 || >=16.2.6"
+    "next": ">=15.5.24 <16 || >=16.3.3"
   },
   "bugs": {
     "url": "https://github.com/opennextjs/opennextjs-aws/issues"