@opennextjs/aws 3.10.1 → 3.10.2

package/dist/adapters/config/index.js

@@ -22,5 +22,10 @@ export const AppPathRoutesManifest =
 /* @__PURE__ */ loadAppPathRoutesManifest(NEXT_DIR);
 export const FunctionsConfigManifest = 
 /* @__PURE__ */ loadFunctionsConfigManifest(NEXT_DIR);
+/**
+ * @deprecated Do not use NEXT_BUILD_ID above Next 16.2, as it could be a fixed value if used in conjonction with deploymentId
+ * We keep it for backward compatibility
+ */
 process.env.NEXT_BUILD_ID = BuildId;
+process.env.OPEN_NEXT_BUILD_ID = NextConfig.deploymentId ?? BuildId;
 process.env.NEXT_PREVIEW_MODE_ID = PrerenderManifest?.preview?.previewModeId;

package/dist/build/patch/astCodePatcher.d.ts

@@ -11,9 +11,11 @@ export type RuleConfig = NapiConfig & {
 /**
  * Returns the `Edit`s and `Match`es for an ast-grep rule in yaml format
  *
- * The rule must have a `fix` to rewrite the matched node.
- *
- * Tip: use https://ast-grep.github.io/playground.html to create rules.
+ * Notes:
+ * - The rule must not contain a `transform` field
+ * - The rule may contain a `fix` field, which is used to generate the edits.
+ *   If not provided, no edits will be generated and the matches will be returned as is.
+ * - You can use https://ast-grep.github.io/playground.html to create and verify rules.
  *
  * @param rule The rule. Either a yaml string or an instance of `RuleConfig`
  * @param root The root node
@@ -31,9 +33,17 @@ export declare function applyRule(rule: string | RuleConfig, root: SgNode, { onc
  *
  * @param path The file path
  * @param lang The language to parse. Defaults to TypeScript.
- * @returns The root for the file.
+ * @returns The root node for the file.
  */
 export declare function parseFile(path: string, lang?: Lang): SgNode;
+/**
+ * Parse a code string and obtain its root.
+ *
+ * @param code The code string
+ * @param lang The language to parse. Defaults to TypeScript.
+ * @returns The root node for the code string.
+ */
+export declare function parseCode(code: string, lang?: Lang): SgNode;
 /**
  * Patches the code from by applying the rule.
  *

package/dist/build/patch/astCodePatcher.js

@@ -5,9 +5,11 @@ import yaml from "yaml";
 /**
  * Returns the `Edit`s and `Match`es for an ast-grep rule in yaml format
  *
- * The rule must have a `fix` to rewrite the matched node.
- *
- * Tip: use https://ast-grep.github.io/playground.html to create rules.
+ * Notes:
+ * - The rule must not contain a `transform` field
+ * - The rule may contain a `fix` field, which is used to generate the edits.
+ *   If not provided, no edits will be generated and the matches will be returned as is.
+ * - You can use https://ast-grep.github.io/playground.html to create and verify rules.
  *
  * @param rule The rule. Either a yaml string or an instance of `RuleConfig`
  * @param root The root node
@@ -19,24 +21,23 @@ export function applyRule(rule, root, { once = false } = {}) {
     if (ruleConfig.transform) {
         throw new Error("transform is not supported");
     }
-    if (!ruleConfig.fix) {
-        throw new Error("no fix to apply");
-    }
-    const fix = ruleConfig.fix;
     const matches = once
         ? [root.find(ruleConfig)].filter((m) => m !== null)
         : root.findAll(ruleConfig);
     const edits = [];
-    matches.forEach((match) => {
-        edits.push(match.replace(
-        // Replace known placeholders by their value
-        fix
-            .replace(/\$\$\$([A-Z0-9_]+)/g, (_m, name) => match
-            .getMultipleMatches(name)
-            .map((n) => n.text())
-            .join(""))
-            .replace(/\$([A-Z0-9_]+)/g, (m, name) => match.getMatch(name)?.text() ?? m)));
-    });
+    const fix = ruleConfig.fix;
+    if (fix !== undefined) {
+        matches.forEach((match) => {
+            edits.push(match.replace(
+            // Replace known placeholders by their value
+            fix
+                .replace(/\$\$\$([A-Z0-9_]+)/g, (_m, name) => match
+                .getMultipleMatches(name)
+                .map((n) => n.text())
+                .join(""))
+                .replace(/\$([A-Z0-9_]+)/g, (m, name) => match.getMatch(name)?.text() ?? m)));
+        });
+    }
     return { edits, matches };
 }
 /**
@@ -44,10 +45,20 @@ export function applyRule(rule, root, { once = false } = {}) {
  *
  * @param path The file path
  * @param lang The language to parse. Defaults to TypeScript.
- * @returns The root for the file.
+ * @returns The root node for the file.
  */
 export function parseFile(path, lang = Lang.TypeScript) {
-    return parse(lang, readFileSync(path, { encoding: "utf-8" })).root();
+    return parseCode(readFileSync(path, { encoding: "utf-8" }), lang);
+}
+/**
+ * Parse a code string and obtain its root.
+ *
+ * @param code The code string
+ * @param lang The language to parse. Defaults to TypeScript.
+ * @returns The root node for the code string.
+ */
+export function parseCode(code, lang = Lang.TypeScript) {
+    return parse(lang, code).root();
 }
 /**
  * Patches the code from by applying the rule.

package/dist/core/routing/cacheInterceptor.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { NextConfig, PrerenderManifest } from "../../adapters/config/index";
 import { emptyReadableStream, toReadableStream } from "../../utils/stream";
 import { isBinaryContentType } from "../../utils/binary";
-import { getTagsFromValue, hasBeenRevalidated } from "../../utils/cache";
+import { getTagsFromValue, hasBeenRevalidated, isStale } from "../../utils/cache";
 import { debug, error } from "../../adapters/logger";
 import { localizePath } from "./i18n";
 import { generateMessageGroupId } from "./queue";
@@ -21,7 +21,7 @@ const VARY_HEADER = "RSC, Next-Router-State-Tree, Next-Router-Prefetch, Next-Rou
 const NEXT_SEGMENT_PREFETCH_HEADER = "next-router-segment-prefetch";
 const NEXT_PRERENDER_HEADER = "x-nextjs-prerender";
 const NEXT_POSTPONED_HEADER = "x-nextjs-postponed";
-async function computeCacheControl(path, body, host, revalidate, lastModified) {
+async function computeCacheControl(path, body, host, revalidate, lastModified, isStaleFromTagCache = false) {
     let finalRevalidate = CACHE_ONE_YEAR;
     const existingRoute = Object.entries(PrerenderManifest?.routes ?? {}).find((p) => p[0] === path)?.[1];
     if (revalidate === undefined && existingRoute) {
@@ -46,19 +46,23 @@ async function computeCacheControl(path, body, host, revalidate, lastModified) {
             etag,
         };
     }
-    if (finalRevalidate !== CACHE_ONE_YEAR) {
-        const sMaxAge = Math.max(finalRevalidate - age, 1);
+    // SSG uses one year cache
+    const isSSG = finalRevalidate === CACHE_ONE_YEAR;
+    const remainingTtl = Math.max(finalRevalidate - age, 1);
+    const isStaleFromTime = !isSSG && remainingTtl === 1;
+    const isStale = isStaleFromTime || isStaleFromTagCache;
+    if (!isSSG || isStaleFromTagCache) {
+        const sMaxAge = isStaleFromTagCache ? 1 : remainingTtl;
         debug("sMaxAge", {
             finalRevalidate,
             age,
             lastModified,
             revalidate,
+            isStaleFromTagCache,
         });
-        const isStale = sMaxAge === 1;
         if (isStale) {
             let url = NextConfig.trailingSlash ? `${path}/` : path;
             if (NextConfig.basePath) {
-                // We need to add the basePath to the url
                 url = `${NextConfig.basePath}${url}`;
             }
             await globalThis.queue.send({
@@ -108,7 +112,7 @@ function getBodyForAppRouter(event, cachedValue) {
         return { body: cachedValue.rsc, additionalHeaders: {} };
     }
 }
-async function generateResult(event, localizedPath, cachedValue, lastModified) {
+async function generateResult(event, localizedPath, cachedValue, lastModified, isStaleFromTagCache = false) {
     debug("Returning result from experimental cache");
     let body = "";
     let type = "application/octet-stream";
@@ -134,7 +138,7 @@ async function generateResult(event, localizedPath, cachedValue, lastModified) {
     else {
         throw new Error("generateResult called with unsupported cache value type, only 'app' and 'page' are supported");
     }
-    const cacheControl = await computeCacheControl(localizedPath, body, event.headers.host, cachedValue.revalidate, lastModified);
+    const cacheControl = await computeCacheControl(localizedPath, body, event.headers.host, cachedValue.revalidate, lastModified, isStaleFromTagCache);
     return {
         type: "core",
         // Sometimes other status codes can be cached, like 404. For these cases, we should return the correct status code
@@ -213,10 +217,10 @@ export async function cacheInterceptor(event) {
             if (!cachedData?.value) {
                 return event;
             }
+            const tags = getTagsFromValue(cachedData.value);
             // We need to check the tag cache now
             if (cachedData.value?.type === "app" ||
                 cachedData.value?.type === "route") {
-                const tags = getTagsFromValue(cachedData.value);
                 const _hasBeenRevalidated = cachedData.shouldBypassTagCache
                     ? false
                     : await hasBeenRevalidated(localizedPath, tags, cachedData);
@@ -224,13 +228,17 @@ export async function cacheInterceptor(event) {
                     return 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());
             const host = event.headers.host;
             switch (cachedData?.value?.type) {
                 case "app":
                 case "page":
-                    return generateResult(event, localizedPath, cachedData.value, cachedData.lastModified);
+                    return generateResult(event, localizedPath, cachedData.value, cachedData.lastModified, _isStale);
                 case "redirect": {
-                    const cacheControl = await computeCacheControl(localizedPath, "", host, cachedData.value.revalidate, cachedData.lastModified);
+                    const cacheControl = await computeCacheControl(localizedPath, "", host, cachedData.value.revalidate, cachedData.lastModified, _isStale);
                     return {
                         type: "core",
                         statusCode: cachedData.value.meta?.status ?? 307,
@@ -244,7 +252,7 @@ export async function cacheInterceptor(event) {
                     };
                 }
                 case "route": {
-                    const cacheControl = await computeCacheControl(localizedPath, cachedData.value.body, host, cachedData.value.revalidate, cachedData.lastModified);
+                    const cacheControl = await computeCacheControl(localizedPath, cachedData.value.body, host, cachedData.value.revalidate, cachedData.lastModified, _isStale);
                     const isBinary = isBinaryContentType(String(cachedData.value.meta?.headers?.["content-type"]));
                     return {
                         type: "core",

package/dist/overrides/cdnInvalidation/cloudfront.js

@@ -11,7 +11,7 @@ export default {
                 ? [`/${path}`, `/${path}?_rsc=*`]
                 : [
                     `/${path}`,
-                    `/_next/data/${process.env.NEXT_BUILD_ID}${path === "/" ? "/index" : `/${path}`}.json*`,
+                    `/_next/data/${process.env.OPEN_NEXT_BUILD_ID}${path === "/" ? "/index" : `/${path}`}.json*`,
                 ];
         });
         await cloudfront.send(new CreateInvalidationCommand({

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

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { getMonorepoRelativePath } from "../../utils/normalize-path";
-const buildId = process.env.NEXT_BUILD_ID;
+const buildId = process.env.OPEN_NEXT_BUILD_ID;
 const basePath = path.join(getMonorepoRelativePath(), `cache/${buildId}`);
 const getCacheKey = (key) => {
     return path.join(basePath, `${key}.cache`);

package/dist/overrides/incrementalCache/multi-tier-ddb-s3.js

@@ -24,8 +24,8 @@ const awsFetch = (body, type = "get") => {
     });
 };
 const buildDynamoKey = (key) => {
-    const { NEXT_BUILD_ID } = process.env;
-    return `__meta_${NEXT_BUILD_ID}_${key}`;
+    const { OPEN_NEXT_BUILD_ID } = process.env;
+    return `__meta_${OPEN_NEXT_BUILD_ID}_${key}`;
 };
 /**
  * This cache implementation uses a multi-tier cache with a local cache, a DynamoDB metadata cache and an S3 cache.

package/dist/overrides/incrementalCache/s3-lite.js

@@ -26,8 +26,8 @@ const awsFetch = async (key, options) => {
     return customFetchClient(client)(url, options);
 };
 function buildS3Key(key, extension) {
-    const { CACHE_BUCKET_KEY_PREFIX, NEXT_BUILD_ID } = process.env;
-    return path.posix.join(CACHE_BUCKET_KEY_PREFIX ?? "", extension === "fetch" ? "__fetch" : "", NEXT_BUILD_ID ?? "", extension === "fetch" ? key : `${key}.${extension}`);
+    const { CACHE_BUCKET_KEY_PREFIX, OPEN_NEXT_BUILD_ID } = process.env;
+    return path.posix.join(CACHE_BUCKET_KEY_PREFIX ?? "", extension === "fetch" ? "__fetch" : "", OPEN_NEXT_BUILD_ID ?? "", extension === "fetch" ? key : `${key}.${extension}`);
 }
 const incrementalCache = {
     async get(key, cacheType) {

package/dist/overrides/incrementalCache/s3.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { DeleteObjectCommand, GetObjectCommand, PutObjectCommand, S3Client, } from "@aws-sdk/client-s3";
 import { awsLogger } from "../../adapters/logger";
 import { parseNumberFromEnv } from "../../adapters/util";
-const { CACHE_BUCKET_REGION, CACHE_BUCKET_KEY_PREFIX, NEXT_BUILD_ID, CACHE_BUCKET_NAME, } = process.env;
+const { CACHE_BUCKET_REGION, CACHE_BUCKET_KEY_PREFIX, OPEN_NEXT_BUILD_ID, CACHE_BUCKET_NAME, } = process.env;
 function parseS3ClientConfigFromEnv() {
     return {
         region: CACHE_BUCKET_REGION,
@@ -12,7 +12,7 @@ function parseS3ClientConfigFromEnv() {
 }
 const s3Client = new S3Client(parseS3ClientConfigFromEnv());
 function buildS3Key(key, extension) {
-    return path.posix.join(CACHE_BUCKET_KEY_PREFIX ?? "", extension === "fetch" ? "__fetch" : "", NEXT_BUILD_ID ?? "", extension === "fetch" ? key : `${key}.${extension}`);
+    return path.posix.join(CACHE_BUCKET_KEY_PREFIX ?? "", extension === "fetch" ? "__fetch" : "", OPEN_NEXT_BUILD_ID ?? "", extension === "fetch" ? key : `${key}.${extension}`);
 }
 const incrementalCache = {
     async get(key, cacheType) {

package/dist/overrides/tagCache/dynamodb-lite.js

@@ -34,10 +34,10 @@ const awsFetch = (body, type = "query") => {
     });
 };
 function buildDynamoKey(key) {
-    const { NEXT_BUILD_ID } = process.env;
+    const { OPEN_NEXT_BUILD_ID } = process.env;
     // FIXME: We should probably use something else than path.join here
     // this could transform some fetch cache key into a valid path
-    return path.posix.join(NEXT_BUILD_ID ?? "", key);
+    return path.posix.join(OPEN_NEXT_BUILD_ID ?? "", key);
 }
 function buildDynamoObject(path, tags, revalidatedAt, stale, expire) {
     const obj = {
@@ -56,7 +56,7 @@ const tagCache = {
             if (globalThis.openNextConfig.dangerous?.disableTagCache) {
                 return [];
             }
-            const { CACHE_DYNAMO_TABLE, NEXT_BUILD_ID } = process.env;
+            const { CACHE_DYNAMO_TABLE, OPEN_NEXT_BUILD_ID } = process.env;
             const store = globalThis.__openNextAls.getStore();
             const cache = store?.requestCache.getOrCreate("dynamoDb:getByPath");
             if (cache?.has(path)) {
@@ -80,7 +80,7 @@ const tagCache = {
             const tags = Items?.map((item) => item.tag.S ?? "") ?? [];
             debug("tags for path", path, tags);
             // We need to remove the buildId from the path
-            const resultTags = tags.map((tag) => tag.replace(`${NEXT_BUILD_ID}/`, ""));
+            const resultTags = tags.map((tag) => tag.replace(`${OPEN_NEXT_BUILD_ID}/`, ""));
             cache?.set(path, resultTags);
             return resultTags;
         }
@@ -94,7 +94,7 @@ const tagCache = {
             if (globalThis.openNextConfig.dangerous?.disableTagCache) {
                 return [];
             }
-            const { CACHE_DYNAMO_TABLE, NEXT_BUILD_ID } = process.env;
+            const { CACHE_DYNAMO_TABLE, OPEN_NEXT_BUILD_ID } = process.env;
             const store = globalThis.__openNextAls.getStore();
             const cache = store?.requestCache.getOrCreate("dynamoDb:getByTag");
             if (cache?.has(tag)) {
@@ -115,7 +115,7 @@ const tagCache = {
             }
             const { Items } = (await result.json());
             // We need to remove the buildId from the path
-            const paths = Items?.map(({ path: { S: key } }) => key?.replace(`${NEXT_BUILD_ID}/`, "") ?? "") ?? [];
+            const paths = Items?.map(({ path: { S: key } }) => key?.replace(`${OPEN_NEXT_BUILD_ID}/`, "") ?? "") ?? [];
             cache?.set(tag, paths);
             return paths;
         }

package/dist/overrides/tagCache/dynamodb-nextMode.js

@@ -33,10 +33,10 @@ const awsFetch = (body, type = "query") => {
     });
 };
 function buildDynamoKey(key) {
-    const { NEXT_BUILD_ID } = process.env;
+    const { OPEN_NEXT_BUILD_ID } = process.env;
     // FIXME: We should probably use something else than path.join here
     // this could transform some fetch cache key into a valid path
-    return path.posix.join(NEXT_BUILD_ID ?? "", "_tag", key);
+    return path.posix.join(OPEN_NEXT_BUILD_ID ?? "", "_tag", key);
 }
 // We use the same key for both path and tag
 // That's mostly for compatibility reason so that it's easier to use this with existing infra
@@ -157,7 +157,12 @@ export default {
         const compute = (item) => {
             if (!item?.stale?.N)
                 return false;
-            return Number.parseInt(item.stale.N) > (lastModified ?? 0);
+            const revalidatedAt = Number.parseInt(item.revalidatedAt?.N ?? "0");
+            // A tag is stale when both its stale timestamp and its revalidatedAt are newer than the page.
+            // revalidatedAt > lastModified ensures the revalidation that set this stale window happened
+            // after the page was generated, preventing a stale signal from a previous ISR cycle.
+            return (revalidatedAt > (lastModified ?? 0) &&
+                Number.parseInt(item.stale.N) >= (lastModified ?? 0));
         };
         const { uncachedTags, hasMatch } = checkItemsCache(tags, itemsCache, compute);
         if (hasMatch)

package/dist/overrides/tagCache/dynamodb.js

@@ -3,7 +3,7 @@ import { BatchWriteItemCommand, DynamoDBClient, QueryCommand, } from "@aws-sdk/c
 import { awsLogger, debug, error } from "../../adapters/logger";
 import { chunk, parseNumberFromEnv } from "../../adapters/util";
 import { MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT, getDynamoBatchWriteCommandConcurrency, } from "./constants";
-const { CACHE_BUCKET_REGION, CACHE_DYNAMO_TABLE, NEXT_BUILD_ID } = process.env;
+const { CACHE_BUCKET_REGION, CACHE_DYNAMO_TABLE, OPEN_NEXT_BUILD_ID } = process.env;
 function parseDynamoClientConfigFromEnv() {
     return {
         region: CACHE_BUCKET_REGION,
@@ -15,7 +15,7 @@ const dynamoClient = new DynamoDBClient(parseDynamoClientConfigFromEnv());
 function buildDynamoKey(key) {
     // FIXME: We should probably use something else than path.join here
     // this could transform some fetch cache key into a valid path
-    return path.posix.join(NEXT_BUILD_ID ?? "", key);
+    return path.posix.join(OPEN_NEXT_BUILD_ID ?? "", key);
 }
 function buildDynamoObject(path, tags, revalidatedAt, stale, expire) {
     const obj = {
@@ -53,7 +53,7 @@ const tagCache = {
             const tags = result.Items?.map((item) => item.tag.S ?? "") ?? [];
             debug("tags for path", path, tags);
             // We need to remove the buildId from the path
-            const resultTags = tags.map((tag) => tag.replace(`${NEXT_BUILD_ID}/`, ""));
+            const resultTags = tags.map((tag) => tag.replace(`${OPEN_NEXT_BUILD_ID}/`, ""));
             cache?.set(path, resultTags);
             return resultTags;
         }
@@ -83,7 +83,7 @@ const tagCache = {
                 },
             }));
             // We need to remove the buildId from the path
-            const paths = Items?.map(({ path: { S: key } }) => key?.replace(`${NEXT_BUILD_ID}/`, "") ?? "") ?? [];
+            const paths = Items?.map(({ path: { S: key } }) => key?.replace(`${OPEN_NEXT_BUILD_ID}/`, "") ?? "") ?? [];
             cache?.set(tag, paths);
             return paths;
         }

package/dist/overrides/tagCache/fs-dev-nextMode.js

@@ -47,7 +47,11 @@ export default {
             if (!tagData || typeof tagData.stale !== "number") {
                 return false;
             }
-            return tagData.stale > (lastModified ?? 0);
+            // A tag is stale when both its stale timestamp and its revalidatedAt are newer than the page.
+            // revalidatedAt > lastModified ensures the revalidation that set this stale window happened
+            // after the page was generated, preventing a stale signal from a previous ISR cycle.
+            return (tagData.revalidatedAt > (lastModified ?? 0) &&
+                tagData.stale >= (lastModified ?? 0));
         });
         debug("isStale result:", hasStaleTag);
         return hasStaleTag;

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

@@ -4,9 +4,9 @@ import { getMonorepoRelativePath } from "../../utils/normalize-path";
 const tagFile = path.join(getMonorepoRelativePath(), "dynamodb-provider/dynamodb-cache.json");
 const tagContent = fs.readFileSync(tagFile, "utf-8");
 let tags = JSON.parse(tagContent);
-const { NEXT_BUILD_ID } = process.env;
+const { OPEN_NEXT_BUILD_ID } = process.env;
 function buildKey(key) {
-    return path.posix.join(NEXT_BUILD_ID ?? "", key);
+    return path.posix.join(OPEN_NEXT_BUILD_ID ?? "", key);
 }
 const tagCache = {
     name: "fs-dev",
@@ -14,12 +14,12 @@ const tagCache = {
     getByPath: async (path) => {
         return tags
             .filter((tagPathMapping) => tagPathMapping.path.S === buildKey(path))
-            .map((tag) => tag.tag.S.replace(`${NEXT_BUILD_ID}/`, ""));
+            .map((tag) => tag.tag.S.replace(`${OPEN_NEXT_BUILD_ID}/`, ""));
     },
     getByTag: async (tag) => {
         return tags
             .filter((tagPathMapping) => tagPathMapping.tag.S === buildKey(tag))
-            .map((tagEntry) => tagEntry.path.S.replace(`${NEXT_BUILD_ID}/`, ""));
+            .map((tagEntry) => tagEntry.path.S.replace(`${OPEN_NEXT_BUILD_ID}/`, ""));
     },
     getLastModified: async (path, lastModified) => {
         // Check if any tag has expired
@@ -46,7 +46,11 @@ const tagCache = {
                 return false;
             if (!entry.stale?.N)
                 return false;
-            return Number.parseInt(entry.stale.N) > (lastModified ?? 0);
+            // A tag is stale when both its stale timestamp and its revalidatedAt are newer than the page.
+            // revalidatedAt > lastModified ensures the revalidation that set this stale window happened
+            // after the page was generated, preventing a stale signal from a previous ISR cycle.
+            return (Number.parseInt(entry.revalidatedAt.N) > (lastModified ?? 0) &&
+                Number.parseInt(entry.stale.N) > (lastModified ?? 0));
         });
     },
     writeTags: async (newTags) => {

package/dist/plugins/edge.js

@@ -145,6 +145,7 @@ ${contents}
   export const PagesManifest = ${JSON.stringify(PagesManifest)};
 
   process.env.NEXT_BUILD_ID = BuildId;
+  process.env.OPEN_NEXT_BUILD_ID = NextConfig.deploymentId ?? BuildId;
   process.env.NEXT_PREVIEW_MODE_ID = PrerenderManifest?.preview?.previewModeId;
 `;
                 return { contents };

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.10.1",
+  "version": "3.10.2",
   "bin": {
     "open-next": "./dist/index.js"
   },