@opennextjs/aws 3.9.16 → 3.10.0

package/dist/adapters/cache.d.ts

@@ -11,7 +11,9 @@ 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>;
-    revalidateTag(tags: string | string[]): Promise<void>;
+    revalidateTag(tags: string | string[], durations?: {
+        expire?: number;
+    }): Promise<void>;
     private updateTagsOnSet;
     private extractRevalidateForSet;
 }

package/dist/adapters/cache.js

@@ -1,5 +1,6 @@
-import { getTagsFromValue, hasBeenRevalidated, writeTags } from "../utils/cache";
+import { getTagsFromValue, hasBeenRevalidated, isStale, writeTags, } from "../utils/cache";
 import { isBinaryContentType } from "../utils/binary";
+import { compareSemver } from "../utils/semver";
 import { debug, error, warn } from "./logger";
 export const SOFT_TAG_PREFIX = "_N_T_/";
 function isFetchCache(options) {
@@ -57,8 +58,11 @@ export default class Cache {
                     }
                 }
             }
+            const _isStale = cachedEntry.shouldBypassTagCache
+                ? false
+                : await isStale(key, _tags, _lastModified);
             return {
-                lastModified: _lastModified,
+                lastModified: _isStale ? 1 : _lastModified,
                 value: cachedEntry.value,
             };
         }
@@ -77,21 +81,27 @@ export default class Cache {
             const cacheData = cachedEntry.value;
             const meta = cacheData.meta;
             const tags = getTagsFromValue(cacheData);
-            const _lastModified = cachedEntry.lastModified ?? Date.now();
+            let _lastModified = cachedEntry.lastModified ?? Date.now();
             const _hasBeenRevalidated = cachedEntry.shouldBypassTagCache
                 ? false
                 : await hasBeenRevalidated(key, tags, cachedEntry);
             if (_hasBeenRevalidated)
                 return null;
+            const _isStale = cachedEntry.shouldBypassTagCache
+                ? false
+                : await isStale(key, tags, _lastModified);
             const store = globalThis.__openNextAls.getStore();
             if (store) {
-                store.lastModified = _lastModified;
+                store.lastModified = _isStale ? 1 : _lastModified;
+                _lastModified = store.lastModified;
             }
             if (cacheData?.type === "route") {
                 return {
                     lastModified: _lastModified,
                     value: {
-                        kind: globalThis.isNextAfter15 ? "APP_ROUTE" : "ROUTE",
+                        kind: compareSemver(globalThis.nextVersion, ">=", "15.0.0")
+                            ? "APP_ROUTE"
+                            : "ROUTE",
                         body: Buffer.from(cacheData.body ?? Buffer.alloc(0), isBinaryContentType(String(meta?.headers?.["content-type"]))
                             ? "base64"
                             : "utf8"),
@@ -101,7 +111,8 @@ export default class Cache {
                 };
             }
             if (cacheData?.type === "page" || cacheData?.type === "app") {
-                if (globalThis.isNextAfter15 && cacheData?.type === "app") {
+                if (compareSemver(globalThis.nextVersion, ">=", "15.0.0") &&
+                    cacheData?.type === "app") {
                     const segmentData = new Map();
                     if (cacheData.segmentData) {
                         for (const [segmentPath, segmentContent] of Object.entries(cacheData.segmentData ?? {})) {
@@ -124,7 +135,9 @@ export default class Cache {
                 return {
                     lastModified: _lastModified,
                     value: {
-                        kind: globalThis.isNextAfter15 ? "PAGES" : "PAGE",
+                        kind: compareSemver(globalThis.nextVersion, ">=", "15.0.0")
+                            ? "PAGES"
+                            : "PAGE",
                         html: cacheData.html,
                         pageData: cacheData.type === "page" ? cacheData.json : cacheData.rsc,
                         status: meta?.status,
@@ -256,7 +269,7 @@ export default class Cache {
             detachedPromise?.resolve();
         }
     }
-    async revalidateTag(tags) {
+    async revalidateTag(tags, durations) {
         const config = globalThis.openNextConfig.dangerous;
         if (config?.disableTagCache || config?.disableIncrementalCache) {
             return;
@@ -268,7 +281,25 @@ export default class Cache {
         try {
             if (globalThis.tagCache.mode === "nextMode") {
                 const paths = (await globalThis.tagCache.getPathsByTags?.(_tags)) ?? [];
-                await writeTags(_tags);
+                const now = Date.now();
+                const tagsToWrite = _tags.map((tag) => {
+                    if (durations) {
+                        // Use provided durations
+                        return {
+                            tag,
+                            stale: now,
+                            expire: durations.expire !== undefined
+                                ? now + durations.expire * 1000
+                                : undefined,
+                        };
+                    }
+                    // Immediate expiration, default behavior before next 16, now only with {expire: 0}
+                    return {
+                        tag,
+                        expire: now,
+                    };
+                });
+                await writeTags(tagsToWrite);
                 if (paths.length > 0) {
                     // TODO: we should introduce a new method in cdnInvalidationHandler to invalidate paths by tags for cdn that supports it
                     // It also means that we'll need to provide the tags used in every request to the wrapper or converter.
@@ -291,10 +322,25 @@ export default class Cache {
                 // Find all keys with the given tag
                 const paths = await globalThis.tagCache.getByTag(tag);
                 debug("Items", paths);
-                const toInsert = paths.map((path) => ({
-                    path,
-                    tag,
-                }));
+                const now = Date.now();
+                const toInsert = paths.map((path) => {
+                    const baseEntry = { path, tag };
+                    if (durations) {
+                        // Use provided durations
+                        return {
+                            ...baseEntry,
+                            stale: now,
+                            expire: durations.expire !== undefined
+                                ? now + durations.expire * 1000
+                                : undefined,
+                        };
+                    }
+                    // Default behavior: immediate expiration
+                    return {
+                        ...baseEntry,
+                        expire: now,
+                    };
+                });
                 // If the tag is a soft tag, we should also revalidate the hard tags
                 if (tag.startsWith(SOFT_TAG_PREFIX)) {
                     for (const path of paths) {
@@ -305,10 +351,22 @@ export default class Cache {
                         for (const hardTag of hardTags) {
                             const _paths = await globalThis.tagCache.getByTag(hardTag);
                             debug({ hardTag, _paths });
-                            toInsert.push(..._paths.map((path) => ({
-                                path,
-                                tag: hardTag,
-                            })));
+                            toInsert.push(..._paths.map((path) => {
+                                const baseEntry = { path, tag: hardTag };
+                                if (durations) {
+                                    return {
+                                        ...baseEntry,
+                                        stale: now,
+                                        expire: durations.expire !== undefined
+                                            ? now + durations.expire * 1000
+                                            : undefined,
+                                    };
+                                }
+                                return {
+                                    ...baseEntry,
+                                    expire: now,
+                                };
+                            }));
                         }
                     }
                 }

package/dist/adapters/composable-cache.d.ts

@@ -21,5 +21,17 @@ declare const _default: {
      */
     expireTags(...tags: string[]): Promise<void>;
     receiveExpiredTags(...tags: string[]): Promise<void>;
+    /**
+     * Added in Next.js 16. Updates tags with optional stale/expire durations.
+     * Mirrors the logic in `Cache.revalidateTag` but without CDN invalidation
+     * since composable cache keys are not URL paths.
+     *
+     * When `durations` is provided, marks tags as stale immediately and optionally
+     * sets an expiry timestamp. When omitted, immediately expires tags (no grace period).
+     * durations.expire is in seconds, but we convert it to milliseconds for storage and comparison.
+     */
+    updateTags(tags: string[], durations?: {
+        expire?: number;
+    }): Promise<void>;
 };
 export default _default;

package/dist/adapters/composable-cache.js

@@ -1,4 +1,4 @@
-import { writeTags } from "../utils/cache";
+import { isStale, writeTags } from "../utils/cache";
 import { fromReadableStream, toReadableStream } from "../utils/stream";
 import { debug } from "./logger";
 const pendingWritePromiseMap = new Map();
@@ -21,14 +21,22 @@ export default {
                 return undefined;
             }
             debug("composable cache result", result);
-            // We need to check if the tags associated with this entry has been revalidated
+            let revalidate = result.value.revalidate;
             if (globalThis.tagCache.mode === "nextMode" &&
                 result.value.tags.length > 0) {
+                // We need to check if the tags associated with this entry has been revalidated
                 const hasBeenRevalidated = result.shouldBypassTagCache
                     ? false
                     : await globalThis.tagCache.hasBeenRevalidated(result.value.tags, result.lastModified);
                 if (hasBeenRevalidated)
                     return undefined;
+                // Check if tags are stale – entry is valid but needs background revalidation
+                const isCacheStale = result.shouldBypassTagCache
+                    ? false
+                    : await isStale(cacheKey, result.value.tags, result.lastModified);
+                if (isCacheStale) {
+                    revalidate = -1;
+                }
             }
             else if (globalThis.tagCache.mode === "original" ||
                 globalThis.tagCache.mode === undefined) {
@@ -37,9 +45,17 @@ export default {
                     : (await globalThis.tagCache.getLastModified(cacheKey, result.lastModified)) === -1;
                 if (hasBeenRevalidated)
                     return undefined;
+                // Check if tags are stale – entry is valid but needs background revalidation
+                const isCacheStale = result.shouldBypassTagCache
+                    ? false
+                    : await isStale(cacheKey, result.value.tags, result.lastModified);
+                if (isCacheStale) {
+                    revalidate = -1;
+                }
             }
             return {
                 ...result.value,
+                revalidate,
                 value: toReadableStream(result.value.value),
             };
         }
@@ -118,4 +134,68 @@ export default {
         // This function does absolutely nothing
         return;
     },
+    /**
+     * Added in Next.js 16. Updates tags with optional stale/expire durations.
+     * Mirrors the logic in `Cache.revalidateTag` but without CDN invalidation
+     * since composable cache keys are not URL paths.
+     *
+     * When `durations` is provided, marks tags as stale immediately and optionally
+     * sets an expiry timestamp. When omitted, immediately expires tags (no grace period).
+     * durations.expire is in seconds, but we convert it to milliseconds for storage and comparison.
+     */
+    async updateTags(tags, durations) {
+        const config = globalThis.openNextConfig.dangerous;
+        if (config?.disableTagCache || config?.disableIncrementalCache) {
+            return;
+        }
+        if (tags.length === 0) {
+            return;
+        }
+        try {
+            const now = Date.now();
+            if (globalThis.tagCache.mode === "nextMode") {
+                const tagsToWrite = tags.map((tag) => {
+                    if (durations) {
+                        return {
+                            tag,
+                            stale: now,
+                            expire: durations.expire !== undefined
+                                ? now + durations.expire * 1000
+                                : undefined,
+                        };
+                    }
+                    // Default: immediate expiry, no grace period
+                    return { tag, expire: now };
+                });
+                await writeTags(tagsToWrite);
+            }
+            else {
+                // Original mode: resolve tag → path mappings first
+                const originalTagCache = globalThis.tagCache;
+                const pathsPerTag = await Promise.all(tags.map(async (tag) => {
+                    const paths = await originalTagCache.getByTag(tag);
+                    return paths.map((path) => {
+                        if (durations) {
+                            return {
+                                path,
+                                tag,
+                                stale: now,
+                                expire: durations.expire !== undefined
+                                    ? now + durations.expire * 1000
+                                    : undefined,
+                            };
+                        }
+                        return { path, tag, expire: now };
+                    });
+                }));
+                const toWrite = pathsPerTag.flat();
+                if (toWrite.length > 0) {
+                    await writeTags(toWrite);
+                }
+            }
+        }
+        catch (e) {
+            debug("Failed to update tags", e);
+        }
+    },
 };

package/dist/adapters/dynamo-provider.js

@@ -30,6 +30,8 @@ async function insert(requestType) {
         tag: item.tag.S,
         path: item.path.S,
         revalidatedAt: Number.parseInt(item.revalidatedAt.N),
+        ...(item.stale && { stale: Number.parseInt(item.stale.N) }),
+        ...(item.expire && { expire: Number.parseInt(item.expire.N) }),
     }));
     await tagCache.writeTags(parsedData);
     return {

package/dist/adapters/revalidate.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { createGenericHandler } from "../core/createGenericHandler.js";
 import { debug, error } from "./logger.js";
 const prerenderManifest = loadPrerenderManifest();
+const ALLOWED_STATUS_CODES = [200, 307, 308, 404];
 const defaultHandler = async (event) => {
     const failedRecords = [];
     for (const record of event.records) {
@@ -32,7 +33,7 @@ const defaultHandler = async (event) => {
                         headers: res.headers,
                         statusCode: res.statusCode,
                     });
-                    if (res.statusCode !== 200 ||
+                    if (!ALLOWED_STATUS_CODES.includes(res.statusCode ?? 0) ||
                         res.headers["x-nextjs-cache"] !== "REVALIDATED") {
                         failedRecords.push(record);
                     }

package/dist/build/compileCache.js

@@ -11,7 +11,6 @@ export function compileCache(options, format = "cjs") {
     const { config } = options;
     const ext = format === "cjs" ? "cjs" : "mjs";
     const compiledCacheFile = path.join(options.buildDir, `cache.${ext}`);
-    const isAfter15 = buildHelper.compareSemver(options.nextVersion, ">=", "15.0.0");
     // Normal cache
     buildHelper.esbuildSync({
         external: ["next", "styled-jsx", "react", "@aws-sdk/*"],
@@ -23,7 +22,7 @@ export function compileCache(options, format = "cjs") {
             js: [
                 `globalThis.disableIncrementalCache = ${config.dangerous?.disableIncrementalCache ?? false};`,
                 `globalThis.disableDynamoDBCache = ${config.dangerous?.disableTagCache ?? false};`,
-                `globalThis.isNextAfter15 = ${isAfter15};`,
+                `globalThis.nextVersion = "${options.nextVersion}";`,
             ].join(""),
         },
     }, options);
@@ -41,7 +40,7 @@ export function compileCache(options, format = "cjs") {
             js: [
                 `globalThis.disableIncrementalCache = ${config.dangerous?.disableIncrementalCache ?? false};`,
                 `globalThis.disableDynamoDBCache = ${config.dangerous?.disableTagCache ?? false};`,
-                `globalThis.isNextAfter15 = ${isAfter15};`,
+                `globalThis.nextVersion = "${options.nextVersion}";`,
             ].join(""),
         },
     }, options);

package/dist/build/copyTracedFiles.d.ts

@@ -6,6 +6,7 @@
  */
 export declare function copyFileAndMakeOwnerWritable(src: string, dest: string): void;
 export declare function isExcluded(srcPath: string): boolean;
+export declare function isNonLinuxPlatformPackage(srcPath: string): boolean;
 interface CopyTracedFilesOptions {
     buildOutputPath: string;
     packagePath: string;

package/dist/build/copyTracedFiles.js

@@ -40,6 +40,12 @@ export function isExcluded(srcPath) {
         escape: false,
     })));
 }
+const NON_LINUX_PLATFORMS = ["darwin", "win32", "freebsd"];
+const platformPattern = NON_LINUX_PLATFORMS.join("|");
+const nonLinuxPlatformRegex = getCrossPlatformPathRegex(`/node_modules/(?:@[^/]+/)?(?:[^/]+-)?(${platformPattern})-[^/]+/`, { escape: false });
+export function isNonLinuxPlatformPackage(srcPath) {
+    return nonLinuxPlatformRegex.test(srcPath);
+}
 function copyPatchFile(outputDir) {
     const patchFile = path.join(__dirname, "patch", "patchedAsyncStorage.js");
     const outputPatchFile = path.join(outputDir, "patchedAsyncStorage.cjs");
@@ -190,11 +196,22 @@ File ${serverPath} does not exist
     const tracedFiles = [];
     const erroredFiles = [];
     //Actually copy the files
+    const skippedPlatformPackages = new Set();
     filesToCopy.forEach((to, from) => {
         // We don't want to copy excluded packages (e.g. sharp)
         if (isExcluded(from)) {
             return;
         }
+        // Skip non-Linux platform-specific native binaries (e.g. @swc/core-darwin-arm64)
+        // Set OPEN_NEXT_SKIP_PLATFORM_FILTER=true to bypass this check
+        if (!process.env.OPEN_NEXT_SKIP_PLATFORM_FILTER &&
+            isNonLinuxPlatformPackage(from)) {
+            const match = from.match(/node_modules\/(?:\.pnpm\/.*\/node_modules\/)?((?:@[^/]+\/)?[^/]+)/);
+            if (match) {
+                skippedPlatformPackages.add(match[1]);
+            }
+            return;
+        }
         tracedFiles.push(to);
         mkdirSync(path.dirname(to), { recursive: true });
         let symlink = null;
@@ -229,6 +246,9 @@ File ${serverPath} does not exist
             }
         }
     });
+    if (skippedPlatformPackages.size > 0) {
+        logger.debug("Skipped non-Linux platform packages:", [...skippedPlatformPackages].join(", "));
+    }
     readdirSync(standaloneNextDir)
         .filter((fileOrDir) => !statSync(path.join(standaloneNextDir, fileOrDir)).isDirectory())
         .forEach((file) => {

package/dist/build/createAssets.js

@@ -39,7 +39,10 @@ export function createStaticAssets(options, { useBasePath = false } = {}) {
     fs.copyFileSync(path.join(appBuildOutputPath, ".next/BUILD_ID"), path.join(outputPath, "BUILD_ID"));
     fs.cpSync(path.join(appBuildOutputPath, ".next/static"), path.join(outputPath, "_next", "static"), { recursive: true });
     if (fs.existsSync(appPublicPath)) {
-        fs.cpSync(appPublicPath, outputPath, { recursive: true });
+        fs.cpSync(appPublicPath, outputPath, {
+            recursive: true,
+            dereference: true,
+        });
     }
     const appSrcPath = fs.existsSync(path.join(appPath, "src"))
         ? "src/app"

package/dist/build/helper.d.ts

@@ -62,16 +62,8 @@ export declare function getHtmlPages(dotNextPath: string): Set<string>;
 export declare function getBuildId(options: BuildOptions): string;
 export declare function getOpenNextVersion(): string;
 export declare function getNextVersion(appPath: string): string;
-export type SemverOp = "=" | ">=" | "<=" | ">" | "<";
-/**
- * Compare two semver versions.
- *
- * @param v1 - First version. Can be "latest", otherwise it should be a valid semver version in the format of `major.minor.patch`. Usually is the next version from the package.json without canary suffix. If minor or patch are missing, they are considered 0.
- * @param v2 - Second version. Should not be "latest", it should be a valid semver version in the format of `major.minor.patch`. If minor or patch are missing, they are considered 0.
- * @example
- *     compareSemver("2.0.0", ">=", "1.0.0") === true
- */
-export declare function compareSemver(v1: string, operator: SemverOp, v2: string): boolean;
+export type { SemverOp } from "../utils/semver.js";
+export { compareSemver } from "../utils/semver.js";
 /**
  * Check if a Next.js version is supported by the Next.js team.
  * Major versions are supported for 2 years following their initial release.

package/dist/build/helper.js

@@ -214,61 +214,7 @@ export function getNextVersion(appPath) {
     // Drop the -canary.n suffix
     return version.split("-")[0];
 }
-/**
- * Compare two semver versions.
- *
- * @param v1 - First version. Can be "latest", otherwise it should be a valid semver version in the format of `major.minor.patch`. Usually is the next version from the package.json without canary suffix. If minor or patch are missing, they are considered 0.
- * @param v2 - Second version. Should not be "latest", it should be a valid semver version in the format of `major.minor.patch`. If minor or patch are missing, they are considered 0.
- * @example
- *     compareSemver("2.0.0", ">=", "1.0.0") === true
- */
-export function compareSemver(v1, operator, v2) {
-    // - = 0 when versions are equal
-    // - > 0 if v1 > v2
-    // - < 0 if v2 > v1
-    let versionDiff = 0;
-    if (v1 === "latest") {
-        versionDiff = 1;
-    }
-    else {
-        if (/^[^\d]/.test(v1)) {
-            // biome-ignore lint/style/noParameterAssign:
-            v1 = v1.substring(1);
-        }
-        if (/^[^\d]/.test(v2)) {
-            // biome-ignore lint/style/noParameterAssign:
-            v2 = v2.substring(1);
-        }
-        const [major1, minor1 = 0, patch1 = 0] = v1.split(".").map(Number);
-        const [major2, minor2 = 0, patch2 = 0] = v2.split(".").map(Number);
-        if (Number.isNaN(major1) || Number.isNaN(major2)) {
-            throw new Error("The major version is required.");
-        }
-        if (major1 !== major2) {
-            versionDiff = major1 - major2;
-        }
-        else if (minor1 !== minor2) {
-            versionDiff = minor1 - minor2;
-        }
-        else if (patch1 !== patch2) {
-            versionDiff = patch1 - patch2;
-        }
-    }
-    switch (operator) {
-        case "=":
-            return versionDiff === 0;
-        case ">=":
-            return versionDiff >= 0;
-        case "<=":
-            return versionDiff <= 0;
-        case ">":
-            return versionDiff > 0;
-        case "<":
-            return versionDiff < 0;
-        default:
-            throw new Error(`Unsupported operator: ${operator}`);
-    }
-}
+export { compareSemver } from "../utils/semver.js";
 /**
  * Next.js major version release dates (YYYY-MM-DD).
  * Each major version is supported for 2 years from its release date.

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

@@ -2,6 +2,7 @@ import type { CodePatcher } from "../codePatcher.js";
 export declare const disablePreloadingRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: if_statement\n    any:\n      - has:\n          kind: member_expression\n          pattern: this.nextConfig.experimental.preloadEntriesOnStart\n          stopBy: end\n      - has:\n          kind: binary_expression\n          pattern: appDocumentPreloading === true\n          stopBy: end\nfix:\n  '{}'\n";
 export declare const removeMiddlewareManifestRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: method_definition\n    has:\n      kind: property_identifier\n      regex: ^getMiddlewareManifest$\nfix:\n  '{return null;}'\n";
 export declare const emptyHandleNextImageRequestRule = "\nrule:\n  kind: assignment_expression\n  pattern: this.handleNextImageRequest = $VALUE\n  inside:\n    kind: method_definition\n    stopBy: end\n    has:\n      kind: property_identifier\n      regex: ^constructor$\n    inside:\n      kind: class_body\nfix:\n  this.handleNextImageRequest = async (req, res, parsedUrl) => false\n";
+export declare const provideInternalWaitUntil = "\nrule:\n  kind: return_statement\n  inside:\n    kind: method_definition\n    stopBy: end\n    has:\n      kind: property_identifier\n      regex: getInternalWaitUntil\n\nfix:\n return globalThis.__openNextAls.getStore()?.waitUntil;\n";
 /**
  * Swaps the body for a throwing implementation
  *

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

@@ -47,6 +47,19 @@ rule:
 fix:
   this.handleNextImageRequest = async (req, res, parsedUrl) => false
 `;
+export const provideInternalWaitUntil = `
+rule:
+  kind: return_statement
+  inside:
+    kind: method_definition
+    stopBy: end
+    has:
+      kind: property_identifier
+      regex: getInternalWaitUntil
+
+fix:
+ return globalThis.__openNextAls.getStore()?.waitUntil;
+`;
 /**
  * Swaps the body for a throwing implementation
  *
@@ -119,6 +132,12 @@ export const patchNextServer = {
             contentFilter: /getMiddlewareManifest/,
             patchCode: createPatchCode(removeMiddlewareManifestRule),
         },
+        {
+            versions: ">=16.0.0",
+            pathFilter,
+            contentFilter: /getInternalWaitUntil/,
+            patchCode: createPatchCode(provideInternalWaitUntil),
+        },
         ...babelPatches,
     ],
 };

package/dist/core/routing/cacheInterceptor.js

@@ -91,7 +91,8 @@ function getBodyForAppRouter(event, cachedValue) {
     try {
         const segmentHeader = `${event.headers[NEXT_SEGMENT_PREFETCH_HEADER]}`;
         const isSegmentResponse = Boolean(segmentHeader) &&
-            segmentHeader in (cachedValue.segmentData || {});
+            segmentHeader in (cachedValue.segmentData || {}) &&
+            !NextConfig.experimental?.prefetchInlining;
         const body = isSegmentResponse
             ? cachedValue.segmentData[segmentHeader]
             : cachedValue.rsc;

package/dist/core/routing/i18n/index.js

@@ -1,7 +1,7 @@
 import { NextConfig } from "../../../adapters/config/index.js";
 import { emptyReadableStream } from "../../../utils/stream.js";
 import { debug } from "../../../adapters/logger.js";
-import { constructNextUrl } from "../util.js";
+import { constructNextUrl, convertToQueryString } from "../util.js";
 import { acceptLanguage } from "./accept-header";
 function isLocalizedPath(path) {
     return (NextConfig.i18n?.locales.includes(path.split("/")[1].toLowerCase()) ?? false);
@@ -119,11 +119,13 @@ export function handleLocaleRedirect(internalEvent) {
     }
     const defaultLocale = domainLocale?.defaultLocale ?? i18n.defaultLocale;
     if (detectedLocale.toLowerCase() !== defaultLocale.toLowerCase()) {
+        const nextUrl = constructNextUrl(internalEvent.url, `/${detectedLocale}${NextConfig.trailingSlash ? "/" : ""}`);
+        const queryString = convertToQueryString(internalEvent.query);
         return {
             type: "core",
             statusCode: 307,
             headers: {
-                Location: constructNextUrl(internalEvent.url, `/${detectedLocale}`),
+                Location: `${nextUrl}${queryString}`,
             },
             body: emptyReadableStream(),
             isBase64Encoded: false,

package/dist/overrides/proxyExternalRequest/fetch.js

@@ -12,7 +12,16 @@ const fetchProxy = {
         });
         const responseHeaders = {};
         response.headers.forEach((value, key) => {
-            responseHeaders[key] = value;
+            const cur = responseHeaders[key];
+            if (cur === undefined) {
+                responseHeaders[key] = value;
+            }
+            else if (Array.isArray(cur)) {
+                cur.push(value);
+            }
+            else {
+                responseHeaders[key] = [cur, value];
+            }
         });
         return {
             type: "core",

package/dist/overrides/tagCache/dummy.js

@@ -14,5 +14,8 @@ const dummyTagCache = {
     writeTags: async () => {
         return;
     },
+    isStale: async (_path) => {
+        return false;
+    },
 };
 export default dummyTagCache;