@opennextjs/aws 4.1.4 → 4.1.6

package/dist/adapters/cache.d.ts

@@ -11,6 +11,7 @@ export default class Cache {
     getFetchCache(key: string, softTags?: string[], tags?: string[]): Promise<CacheHandlerValue | null>;
     getIncrementalCache(key: string): Promise<CacheHandlerValue | null>;
     set(key: string, data?: IncrementalCacheValue, ctx?: IncrementalCacheContext): Promise<void>;
+    private writeCache;
     revalidateTag(tags: string | string[], durations?: {
         expire?: number;
     }): Promise<void>;

package/dist/adapters/cache.js

@@ -195,11 +195,18 @@ export default class Cache {
         if (globalThis.openNextConfig.dangerous?.disableIncrementalCache) {
             return;
         }
-        // This one might not even be necessary anymore
-        // Better be safe than sorry
-        const detachedPromise = globalThis.__openNextAls
-            .getStore()
-            ?.pendingPromiseRunner.withResolvers();
+        const store = globalThis.__openNextAls.getStore();
+        const writePromise = this.writeCache(key, data, ctx);
+        // Next.js ignores the value returned by `set`, so the write is registered on the request's
+        // pending promise runner instead of being awaited. `FETCH` writes are awaited: Next.js runs
+        // them in a detached chain of its own that only covers the write while `set` waits for it.
+        if (data?.kind === "FETCH" || store === undefined) {
+            await writePromise;
+            return;
+        }
+        store.pendingPromiseRunner.add(writePromise);
+    }
+    async writeCache(key, data, ctx) {
         try {
             if (data === null || data === undefined) {
                 await globalThis.incrementalCache.delete(key);
@@ -292,10 +299,6 @@ export default class Cache {
         catch (e) {
             error("Failed to set cache", e);
         }
-        finally {
-            // We need to resolve the promise even if there was an error
-            detachedPromise?.resolve();
-        }
     }
     async revalidateTag(tags, durations) {
         const config = globalThis.openNextConfig.dangerous;

package/dist/adapters/composable-cache.js

@@ -1,13 +1,34 @@
 import { isStale, writeTags } from "../utils/cache";
 import { fromReadableStream, toReadableStream } from "../utils/stream";
 import { debug } from "./logger";
-const pendingWritePromiseMap = new Map();
+/**
+ * In-flight writes are tracked per request, not per module.
+ *
+ * A module-scope map is per isolate. On a runtime that serves one request per
+ * sandbox that is the same as per request, but on a runtime that serves many
+ * concurrent requests from one isolate (e.g. Cloudflare Workers) a pending
+ * write promise created in request A would be handed to request B. If A's
+ * context is torn down before the write settles, B awaits a promise that never
+ * resolves, `.finally()` never runs, and the key stays poisoned for the life of
+ * the isolate.
+ *
+ * `RequestCache` is the per-request store the tag caches already use for this.
+ * Scoping the map to it keeps the read-coherence a `get` needs for a write in
+ * flight from the same render while making a cross-request share impossible.
+ * With no ALS store (e.g. at build time) the dedupe is skipped and `get` falls
+ * through to the incremental cache.
+ */
+const PENDING_WRITES_CACHE_KEY = "composable-cache:pending-writes";
+const getPendingWritePromiseMap = () => globalThis.__openNextAls
+    ?.getStore()
+    ?.requestCache?.getOrCreate(PENDING_WRITES_CACHE_KEY);
 export default {
     async get(cacheKey) {
         try {
             // We first check if we have a pending write for this cache key
             // If we do, we return the pending promise instead of fetching the cache
-            if (pendingWritePromiseMap.has(cacheKey)) {
+            const pendingWritePromiseMap = getPendingWritePromiseMap();
+            if (pendingWritePromiseMap?.has(cacheKey)) {
                 const stored = pendingWritePromiseMap.get(cacheKey);
                 if (stored) {
                     return stored.then((entry) => ({
@@ -69,9 +90,10 @@ export default {
             ...entry,
             value: await fromReadableStream(entry.value),
         }));
-        pendingWritePromiseMap.set(cacheKey, promiseEntry);
+        const pendingWritePromiseMap = getPendingWritePromiseMap();
+        pendingWritePromiseMap?.set(cacheKey, promiseEntry);
         const entry = await promiseEntry.finally(() => {
-            pendingWritePromiseMap.delete(cacheKey);
+            pendingWritePromiseMap?.delete(cacheKey);
         });
         await globalThis.incrementalCache.set(cacheKey, {
             ...entry,

package/dist/build/buildNextApp.js

@@ -15,5 +15,10 @@ export function buildNextjsApp(options) {
     cp.execSync(command, {
         stdio: "inherit",
         cwd: path.dirname(options.appPackageJsonPath),
+        // `setStandaloneBuildMode` mutates `process.env` right before this call.
+        // Node forwards those mutations to the child by default, but Bun resolves
+        // the child environment from a snapshot taken at startup unless `env` is
+        // passed explicitly, so `NEXT_PRIVATE_STANDALONE` never reaches the build.
+        env: process.env,
     });
 }

package/dist/build/createServerBundle.js

@@ -168,6 +168,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
                     ? ["experimentalIncrementalCacheHandler"]
                     : ["stableIncrementalCache"]),
                 ...(isAfter152 ? [] : ["composableCache"]),
+                ...(isAfter152 ? [] : ["topLevelComposableCache"]),
             ],
         }),
         openNextResolvePlugin({

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

@@ -1,4 +1,4 @@
-export declare const rule = "\nrule:\n  kind: binary_expression\n  all:\n    - has:\n        kind: unary_expression\n        regex: \"!cachedResponse.isStale\"\n    -  has:\n         kind: member_expression\n         regex: \"context.isPrefetch\"\nfix:\n  'true'";
+export declare const rule = "\nrule:\n  kind: binary_expression\n  all:\n    - has:\n        kind: unary_expression\n        pattern: \"!$ENTRY.isStale\"\n    -  has:\n         kind: member_expression\n         regex: \"context.isPrefetch\"\nfix:\n  'true'";
 export declare const patchBackgroundRevalidation: {
     name: string;
     patches: {

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

@@ -6,7 +6,7 @@ rule:
   all:
     - has:
         kind: unary_expression
-        regex: "!cachedResponse.isStale"
+        pattern: "!$ENTRY.isStale"
     -  has:
          kind: member_expression
          regex: "context.isPrefetch"

package/dist/core/routing/cacheInterceptor.js

@@ -38,7 +38,9 @@ async function computeCacheControl(path, body, host, revalidate, lastModified, i
     // calculate age
     const age = Math.round((Date.now() - (lastModified ?? 0)) / 1000);
     const hash = (str) => createHash("md5").update(str).digest("hex");
-    const etag = hash(body);
+    // RFC 9110 entity-tag is a quoted opaque-tag. CloudFront drops unquoted ETags
+    // when serving compressed objects.
+    const etag = `"${hash(body)}"`;
     if (revalidate === 0) {
         // This one should never happen
         return {
@@ -102,18 +104,33 @@ function getBodyForAppRouter(event, cachedValue) {
     if (cachedValue.type !== "app") {
         throw new Error("getBodyForAppRouter called with non-app cache value");
     }
-    const segmentHeader = `${event.headers[NEXT_SEGMENT_PREFETCH_HEADER]}`;
-    const isSegmentResponse = Boolean(segmentHeader) &&
-        segmentHeader in (cachedValue.segmentData || {}) &&
-        !NextConfig.experimental?.prefetchInlining;
-    if (isSegmentResponse) {
-        return {
-            body: cachedValue.segmentData[segmentHeader],
-            additionalHeaders: {
-                [NEXT_PRERENDER_HEADER]: "1",
-                [NEXT_POSTPONED_HEADER]: "2",
-            },
-        };
+    const segmentHeader = event.headers[NEXT_SEGMENT_PREFETCH_HEADER];
+    // A request from the client Segment Cache has to be answered with the segment it asked
+    // for. The full page payload is not a different-but-valid answer: the router never
+    // records the prefetch as satisfied and re-requests it forever.
+    // This mirrors how Next serves a cached app page - see the `segmentPrefetchHeader`
+    // branch of `packages/next/src/build/templates/app-page.ts`, which responds with the
+    // matching segment or an empty 404, and never with the full page.
+    //
+    // `experimental.prefetchInlining` is deliberately not consulted. Next normalizes every
+    // truthy value - including the 16.2+ default - into `{ maxSize, maxBundleSize }`, so it
+    // must never be read as a flag. More importantly it has no say here: inlining only
+    // changes *which* segments the build emits (an emitted segment then being a bundle that
+    // already holds its inlined ancestors), and `segmentData` holds exactly the segments
+    // that were emitted, which is exactly the set the router asks for.
+    if (typeof segmentHeader === "string" && cachedValue.segmentData) {
+        if (Object.hasOwn(cachedValue.segmentData, segmentHeader)) {
+            return {
+                body: cachedValue.segmentData[segmentHeader],
+                additionalHeaders: {
+                    [NEXT_PRERENDER_HEADER]: "1",
+                    [NEXT_POSTPONED_HEADER]: "2",
+                },
+            };
+        }
+        // The entry holds segments, but not this one. Next answers with an empty 404 here -
+        // let the server do that rather than serving a payload of a different shape.
+        return undefined;
     }
     // `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`.

package/dist/core/routing/middleware.js

@@ -1,4 +1,5 @@
 import { FunctionsConfigManifest, MiddlewareManifest, NextConfig, PrerenderManifest, } from "../../adapters/config/index.js";
+import { parseSetCookieHeader } from "../../http/util.js";
 import { ISR_HEADER, PRERENDER_REVALIDATE_HEADER } from "../../utils/cacheHeaders.js";
 import { emptyReadableStream } from "../../utils/stream.js";
 import { getQueryFromSearchParams } from "../../overrides/converters/utils.js";
@@ -112,7 +113,12 @@ export async function handleMiddleware(internalEvent, initialSearch, middlewareL
             }
         }
     });
-    const setCookies = responseHeaders.getSetCookie();
+    // Next folds the cookies set through `cookies()` in the middleware into a single
+    // comma-joined `set-cookie` header, so each entry here may be compound.
+    // Next itself splits them back in `runMiddleware` (`next-server.ts`).
+    const setCookies = responseHeaders
+        .getSetCookie()
+        .flatMap((maybeCompoundCookie) => parseSetCookieHeader(maybeCompoundCookie));
     if (setCookies.length > 0) {
         resHeaders["set-cookie"] = setCookies;
     }

package/dist/core/util.js

@@ -33,6 +33,19 @@ const nextServer = new NextServer.default({
         cacheHandler: cacheHandlerPath,
         cacheMaxMemorySize: 0, // We need to disable memory cache
         //#endOverride
+        // Next.js 16 promoted `cacheHandlers` out of `experimental` to a top-level
+        // config key. At runtime `route-module.js#loadCustomCacheHandlers` reads
+        // `nextConfig.cacheHandlers` (top-level) — the nested `experimental` copy
+        // below is ignored on Next >= 16, so the composable ("use cache") handler
+        // must also be registered here or Next falls back to its in-memory default
+        // and composable entries never reach the incremental cache override.
+        // Older Next versions ignore this unknown top-level key and read the
+        // `experimental` copy instead; setting both is safe across versions.
+        //#override topLevelComposableCache
+        cacheHandlers: {
+            default: composableCacheHandlerPath,
+        },
+        //#endOverride
         experimental: {
             ...NextConfig.experimental,
             // This uses the request.headers.host as the URL

package/dist/overrides/incrementalCache/fs-dev.js

@@ -2,24 +2,49 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { getMonorepoRelativePath } from "../../utils/normalize-path";
 const buildId = process.env.OPEN_NEXT_BUILD_ID;
-const basePath = path.join(getMonorepoRelativePath(), `cache/${buildId}`);
-const getCacheKey = (key) => {
-    return path.join(basePath, `${key}.cache`);
+const basePath = path.join(getMonorepoRelativePath(), "cache");
+/**
+ * Resolves a cache entry using the same layout as the build's cache assets.
+ *
+ * @param key The cache entry key
+ * @param cacheType The cache namespace, defaulting to the page/route cache
+ * @returns The file path for the entry
+ */
+const getCacheKey = (key, cacheType = "cache") => {
+    return path.join(basePath, cacheType === "fetch" ? "__fetch" : "", `${buildId}`, cacheType === "fetch" ? key : `${key}.${cacheType}`);
 };
 const cache = {
     name: "fs-dev",
-    get: async (key) => {
-        const fileData = await fs.readFile(getCacheKey(key), "utf-8");
+    /**
+     * Reads an entry from the selected cache namespace.
+     *
+     * @param key The cache entry key
+     * @param cacheType The cache namespace, defaulting to the page/route cache
+     * @returns The cached value and its last modification time
+     * @throws When the entry cannot be read or contains invalid JSON
+     */
+    get: async (key, cacheType) => {
+        const cacheKey = getCacheKey(key, cacheType);
+        const fileData = await fs.readFile(cacheKey, "utf-8");
         const data = JSON.parse(fileData);
-        const { mtime } = await fs.stat(getCacheKey(key));
+        const { mtime } = await fs.stat(cacheKey);
         return {
             value: data,
             lastModified: mtime.getTime(),
         };
     },
-    set: async (key, value, isFetch) => {
+    /**
+     * Writes an entry to the selected cache namespace.
+     *
+     * @param key The cache entry key
+     * @param value The value to persist
+     * @param cacheType The cache namespace, defaulting to the page/route cache
+     * @returns A promise that resolves when the entry has been written
+     * @throws When serialization or a file system operation fails
+     */
+    set: async (key, value, cacheType) => {
         const data = JSON.stringify(value);
-        const cacheKey = getCacheKey(key);
+        const cacheKey = getCacheKey(key, cacheType);
         // We need to create the directory before writing the file
         await fs.mkdir(path.dirname(cacheKey), { recursive: true });
         await fs.writeFile(cacheKey, data);

package/dist/overrides/queue/sqs-lite.js

@@ -29,21 +29,33 @@ const awsFetch = (body) => {
 };
 const queue = {
     send: async ({ MessageBody, MessageDeduplicationId, MessageGroupId }) => {
-        try {
-            const { REVALIDATION_QUEUE_URL } = process.env;
-            const result = await awsFetch(JSON.stringify({
-                QueueUrl: REVALIDATION_QUEUE_URL,
-                MessageBody: JSON.stringify(MessageBody),
-                MessageDeduplicationId,
-                MessageGroupId,
-            }));
-            if (result.status !== 200) {
-                throw new RecoverableError(`Failed to send message: ${result.status}`);
+        const send = (async () => {
+            try {
+                const { REVALIDATION_QUEUE_URL } = process.env;
+                const result = await awsFetch(JSON.stringify({
+                    QueueUrl: REVALIDATION_QUEUE_URL,
+                    MessageBody: JSON.stringify(MessageBody),
+                    MessageDeduplicationId,
+                    MessageGroupId,
+                }));
+                if (result.status !== 200) {
+                    throw new RecoverableError(`Failed to send message: ${result.status}`);
+                }
             }
+            catch (e) {
+                error(e);
+            }
+        })();
+        // Enqueuing revalidation should not block the response. When the wrapper
+        // provides a `waitUntil`, hand the send to it and return immediately so the
+        // SQS round trip runs after the body is flushed; otherwise (edge, or a
+        // wrapper without `waitUntil`) fall back to awaiting it inline.
+        const waitUntil = globalThis.__openNextAls.getStore()?.waitUntil;
+        if (waitUntil) {
+            waitUntil(send);
+            return;
         }
-        catch (e) {
-            error(e);
-        }
+        await send;
     },
     name: "sqs",
 };

package/dist/overrides/queue/sqs.js

@@ -8,12 +8,24 @@ const sqsClient = new SQSClient({
 });
 const queue = {
     send: async ({ MessageBody, MessageDeduplicationId, MessageGroupId }) => {
-        await sqsClient.send(new SendMessageCommand({
+        const send = sqsClient
+            .send(new SendMessageCommand({
             QueueUrl: REVALIDATION_QUEUE_URL,
             MessageBody: JSON.stringify(MessageBody),
             MessageDeduplicationId,
             MessageGroupId,
-        }));
+        }))
+            .then(() => undefined);
+        // Enqueuing revalidation should not block the response. When the wrapper
+        // provides a `waitUntil`, hand the send to it and return immediately so the
+        // SQS round trip runs after the body is flushed; otherwise (edge, or a
+        // wrapper without `waitUntil`) fall back to awaiting it inline.
+        const waitUntil = globalThis.__openNextAls.getStore()?.waitUntil;
+        if (waitUntil) {
+            waitUntil(send);
+            return;
+        }
+        await send;
     },
     name: "sqs",
 };

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

@@ -1,5 +1,6 @@
 import { Readable } from "node:stream";
 import { debug } from "../../adapters/logger";
+import { DetachedPromiseRunner } from "../../utils/promise";
 function formatWarmerResponse(event) {
     const result = new Promise((resolve) => {
         setTimeout(() => {
@@ -42,6 +43,15 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
         debug(err);
         responseStream.end();
     });
+    // AWS provides no native `waitUntil`, so back it with the shared
+    // `DetachedPromiseRunner`, which tracks the deferred promises and awaits
+    // (and logs the failures of) them before the stream closes. This keeps
+    // the Lambda alive for deferred work (background revalidation, cache
+    // write-through) that starts after the response body is sent — matching
+    // the `waitUntil` the Cloudflare wrappers pass through, and enabling the
+    // `withWaitUntil` route preloading that otherwise falls back to `none`.
+    const promiseRunner = new DetachedPromiseRunner();
+    const waitUntil = (promise) => promiseRunner.add(promise);
     const streamCreator = {
         writeHeaders: (_prelude) => {
             // No content-encoding header — API Gateway streaming does not
@@ -55,7 +65,10 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
             return responseStream;
         },
     };
-    const response = await handler(internalEvent, { streamCreator });
+    const response = await handler(internalEvent, {
+        streamCreator,
+        waitUntil,
+    });
     const isUsingEdge = globalThis.isEdgeRuntime ?? false;
     if (isUsingEdge) {
         debug("Headers has not been set, we must be in the edge runtime");
@@ -66,6 +79,8 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
         });
         Readable.fromWeb(response.body).pipe(stream);
     }
+    // Keep the invocation alive until deferred `waitUntil` work settles.
+    await promiseRunner.await();
 });
 export default {
     wrapper: handler,

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

@@ -1,6 +1,7 @@
 import { Readable } from "node:stream";
 import zlib from "node:zlib";
 import { debug, error } from "../../adapters/logger";
+import { DetachedPromiseRunner } from "../../utils/promise";
 function formatWarmerResponse(event) {
     const result = new Promise((resolve) => {
         setTimeout(() => {
@@ -64,7 +65,19 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
             return compressedStream ?? responseStream;
         },
     };
-    const response = await handler(internalEvent, { streamCreator });
+    // AWS provides no native `waitUntil`, so back it with the shared
+    // `DetachedPromiseRunner`, which tracks the deferred promises and awaits
+    // (and logs the failures of) them before the stream closes. This keeps
+    // the Lambda alive for deferred work (background revalidation, cache
+    // write-through) that starts after the response body is sent — matching
+    // the `waitUntil` the Cloudflare wrappers pass through, and enabling the
+    // `withWaitUntil` route preloading that otherwise falls back to `none`.
+    const promiseRunner = new DetachedPromiseRunner();
+    const waitUntil = (promise) => promiseRunner.add(promise);
+    const response = await handler(internalEvent, {
+        streamCreator,
+        waitUntil,
+    });
     const isUsingEdge = globalThis.isEdgeRuntime ?? false;
     if (isUsingEdge) {
         debug("Headers has not been set, we must be in the edge runtime");
@@ -75,6 +88,8 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
         });
         Readable.fromWeb(response.body).pipe(stream);
     }
+    // Keep the invocation alive until deferred `waitUntil` work settles.
+    await promiseRunner.await();
     // return converter.convertTo(response);
 });
 export default {

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

@@ -73,7 +73,10 @@ export interface NextConfig {
         serverActions?: boolean;
         appDir?: boolean;
         optimizeCss?: boolean;
-        prefetchInlining?: boolean;
+        prefetchInlining?: boolean | {
+            maxSize: number;
+            maxBundleSize: number;
+        };
     };
     images: ImageConfig;
     poweredByHeader?: boolean;

package/package.json

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