@opennextjs/aws 4.1.0 → 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/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",
@@ -239,8 +268,11 @@ export async function cacheInterceptor(event) {
             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/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/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/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.1.0",
+  "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.21 <16 || >=16.2.11"
+    "next": ">=15.5.24 <16 || >=16.3.3"
   },
   "bugs": {
     "url": "https://github.com/opennextjs/opennextjs-aws/issues"