@opennextjs/aws 3.5.1 → 3.5.3

package/dist/adapters/config/util.d.ts

@@ -2,6 +2,7 @@ import type { FunctionsConfigManifest, MiddlewareManifest, NextConfig, Prerender
 import type { PublicFiles } from "../../build";
 export declare function loadConfig(nextDir: string): NextConfig;
 export declare function loadBuildId(nextDir: string): string;
+export declare function loadPagesManifest(nextDir: string): any;
 export declare function loadHtmlPages(nextDir: string): string[];
 export declare function loadPublicAssets(openNextDir: string): PublicFiles;
 export declare function loadRoutesManifest(nextDir: string): {

package/dist/adapters/config/util.js

@@ -10,10 +10,13 @@ export function loadBuildId(nextDir) {
     const filePath = path.join(nextDir, "BUILD_ID");
     return fs.readFileSync(filePath, "utf-8").trim();
 }
-export function loadHtmlPages(nextDir) {
+export function loadPagesManifest(nextDir) {
     const filePath = path.join(nextDir, "server/pages-manifest.json");
     const json = fs.readFileSync(filePath, "utf-8");
-    return Object.entries(JSON.parse(json))
+    return JSON.parse(json);
+}
+export function loadHtmlPages(nextDir) {
+    return Object.entries(loadPagesManifest(nextDir))
         .filter(([_, value]) => value.endsWith(".html"))
         .map(([key]) => key);
 }

package/dist/adapters/logger.js

@@ -1,4 +1,4 @@
-import { isOpenNextError } from "../utils/error";
+import { isOpenNextError } from "../utils/error.js";
 export function debug(...args) {
     if (globalThis.openNextDebug) {
         console.log(...args);

package/dist/build/compileCache.js

@@ -11,7 +11,7 @@ export function compileCache(options, format = "cjs") {
     const { config } = options;
     const ext = format === "cjs" ? "cjs" : "mjs";
     const outFile = path.join(options.buildDir, `cache.${ext}`);
-    const isAfter15 = buildHelper.compareSemver(options.nextVersion, "15.0.0") >= 0;
+    const isAfter15 = buildHelper.compareSemver(options.nextVersion, ">=", "15.0.0");
     buildHelper.esbuildSync({
         external: ["next", "styled-jsx", "react", "@aws-sdk/*"],
         entryPoints: [path.join(options.openNextDistDir, "adapters", "cache.js")],

package/dist/build/constant.d.ts

@@ -1 +1,2 @@
 export declare const MIDDLEWARE_TRACE_FILE = "server/middleware.js.nft.json";
+export declare const INSTRUMENTATION_TRACE_FILE = "server/instrumentation.js.nft.json";

package/dist/build/constant.js

@@ -1,2 +1,3 @@
 //TODO: Move all other manifest path here as well
 export const MIDDLEWARE_TRACE_FILE = "server/middleware.js.nft.json";
+export const INSTRUMENTATION_TRACE_FILE = "server/instrumentation.js.nft.json";

package/dist/build/copyTracedFiles.d.ts

@@ -6,5 +6,25 @@ interface CopyTracedFilesOptions {
     bundledNextServer: boolean;
     skipServerFiles?: boolean;
 }
-export declare function copyTracedFiles({ buildOutputPath, packagePath, outputDir, routes, bundledNextServer, skipServerFiles, }: CopyTracedFilesOptions): Promise<void>;
+export declare function getManifests(nextDir: string): {
+    buildId: string;
+    config: import("../types/next-types.js").NextConfig;
+    prerenderManifest: import("../types/next-types.js").PrerenderManifest;
+    pagesManifest: any;
+    appPathsManifest: Record<string, string>;
+    middlewareManifest: import("../types/next-types.js").MiddlewareManifest;
+    functionsConfigManifest: import("../types/next-types.js").FunctionsConfigManifest;
+};
+export declare function copyTracedFiles({ buildOutputPath, packagePath, outputDir, routes, bundledNextServer, skipServerFiles, }: CopyTracedFilesOptions): Promise<{
+    tracedFiles: string[];
+    manifests: {
+        buildId: string;
+        config: import("../types/next-types.js").NextConfig;
+        prerenderManifest: import("../types/next-types.js").PrerenderManifest;
+        pagesManifest: any;
+        appPathsManifest: Record<string, string>;
+        middlewareManifest: import("../types/next-types.js").MiddlewareManifest;
+        functionsConfigManifest: import("../types/next-types.js").FunctionsConfigManifest;
+    };
+}>;
 export {};

package/dist/build/copyTracedFiles.js

@@ -1,15 +1,38 @@
 import url from "node:url";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, statSync, symlinkSync, writeFileSync, } from "node:fs";
 import path from "node:path";
-import { loadConfig, loadPrerenderManifest } from "../adapters/config/util.js";
+import { loadAppPathsManifest, loadBuildId, loadConfig, loadFunctionsConfigManifest, loadMiddlewareManifest, loadPagesManifest, loadPrerenderManifest, } from "../adapters/config/util.js";
+import { getCrossPlatformPathRegex } from "../utils/regex.js";
 import logger from "../logger.js";
-import { MIDDLEWARE_TRACE_FILE } from "./constant.js";
+import { INSTRUMENTATION_TRACE_FILE, MIDDLEWARE_TRACE_FILE, } from "./constant.js";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
+//TODO: we need to figure which packages we could safely remove
+const EXCLUDED_PACKAGES = [
+    "caniuse-lite",
+    "sharp",
+    // This seems to be only in Next 15
+    // Some of sharp deps are under the @img scope
+    "@img",
+];
+function isExcluded(srcPath) {
+    return EXCLUDED_PACKAGES.some((excluded) => srcPath.match(getCrossPlatformPathRegex(`/node_modules/${excluded}/`)));
+}
 function copyPatchFile(outputDir) {
     const patchFile = path.join(__dirname, "patch", "patchedAsyncStorage.js");
     const outputPatchFile = path.join(outputDir, "patchedAsyncStorage.cjs");
     copyFileSync(patchFile, outputPatchFile);
 }
+export function getManifests(nextDir) {
+    return {
+        buildId: loadBuildId(nextDir),
+        config: loadConfig(nextDir),
+        prerenderManifest: loadPrerenderManifest(nextDir),
+        pagesManifest: loadPagesManifest(nextDir),
+        appPathsManifest: loadAppPathsManifest(nextDir),
+        middlewareManifest: loadMiddlewareManifest(nextDir),
+        functionsConfigManifest: loadFunctionsConfigManifest(nextDir),
+    };
+}
 // eslint-disable-next-line sonarjs/cognitive-complexity
 export async function copyTracedFiles({ buildOutputPath, packagePath, outputDir, routes, bundledNextServer, skipServerFiles, }) {
     const tsStart = Date.now();
@@ -88,10 +111,18 @@ File ${fullFilePath} does not exist
             }
         }
     };
+    // Check for instrumentation trace file
+    if (existsSync(path.join(dotNextDir, INSTRUMENTATION_TRACE_FILE))) {
+        // We still need to copy the nft.json file so that computeCopyFilesForPage doesn't throw
+        copyFileSync(path.join(dotNextDir, INSTRUMENTATION_TRACE_FILE), path.join(standaloneNextDir, INSTRUMENTATION_TRACE_FILE));
+        computeCopyFilesForPage("instrumentation");
+        logger.debug("Adding instrumentation trace files");
+    }
     if (existsSync(path.join(dotNextDir, MIDDLEWARE_TRACE_FILE))) {
         // We still need to copy the nft.json file so that computeCopyFilesForPage doesn't throw
         copyFileSync(path.join(dotNextDir, MIDDLEWARE_TRACE_FILE), path.join(standaloneNextDir, MIDDLEWARE_TRACE_FILE));
         computeCopyFilesForPage("middleware");
+        logger.debug("Adding node middleware trace files");
     }
     const hasPageDir = routes.some((route) => route.startsWith("pages/"));
     const hasAppDir = routes.some((route) => route.startsWith("app/"));
@@ -119,11 +150,8 @@ File ${fullFilePath} does not exist
     });
     //Actually copy the files
     filesToCopy.forEach((to, from) => {
-        if (
-        //TODO: we need to figure which packages we could safely remove
-        from.includes(path.join("node_modules", "caniuse-lite")) ||
-            // from.includes("jest-worker") || This ones seems necessary for next 12
-            from.includes(path.join("node_modules", "sharp"))) {
+        // We don't want to copy excluded packages (i.e sharp)
+        if (isExcluded(from)) {
             return;
         }
         mkdirSync(path.dirname(to), { recursive: true });
@@ -204,4 +232,8 @@ File ${fullFilePath} does not exist
             .forEach((file) => copyStaticFile(`server/${file}`));
     }
     logger.debug("copyTracedFiles:", Date.now() - tsStart, "ms");
+    return {
+        tracedFiles: Array.from(filesToCopy.values()),
+        manifests: getManifests(standaloneNextDir),
+    };
 }

package/dist/build/createImageOptimizationBundle.js

@@ -26,7 +26,7 @@ export async function createImageOptimizationBundle(options) {
             },
         }),
     ];
-    if (buildHelper.compareSemver(options.nextVersion, "14.1.1") >= 0) {
+    if (buildHelper.compareSemver(options.nextVersion, ">=", "14.1.1")) {
         plugins.push(openNextReplacementPlugin({
             name: "opennext-14.1.1-image-optimization",
             target: getCrossPlatformPathRegex("plugins/image-optimization/image-optimization.js"),

package/dist/build/createServerBundle.d.ts

@@ -1,2 +1,10 @@
+import type { Plugin } from "esbuild";
+import { ContentUpdater } from "../plugins/content-updater.js";
 import * as buildHelper from "./helper.js";
-export declare function createServerBundle(options: buildHelper.BuildOptions): Promise<void>;
+import { type CodePatcher } from "./patch/codePatcher.js";
+interface CodeCustomization {
+    additionalCodePatches?: CodePatcher[];
+    additionalPlugins?: (contentUpdater: ContentUpdater) => Plugin[];
+}
+export declare function createServerBundle(options: buildHelper.BuildOptions, codeCustomization?: CodeCustomization): Promise<void>;
+export {};

package/dist/build/createServerBundle.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import logger from "../logger.js";
 import { minifyAll } from "../minimize-js.js";
+import { ContentUpdater } from "../plugins/content-updater.js";
 import { openNextReplacementPlugin } from "../plugins/replacement.js";
 import { openNextResolvePlugin } from "../plugins/resolve.js";
 import { getCrossPlatformPathRegex } from "../utils/regex.js";
@@ -11,7 +12,10 @@ import { copyTracedFiles } from "./copyTracedFiles.js";
 import { generateEdgeBundle } from "./edge/createEdgeBundle.js";
 import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
-export async function createServerBundle(options) {
+import { applyCodePatches } from "./patch/codePatcher.js";
+import { patchFetchCacheForISR, patchUnstableCacheForISR, } from "./patch/patchFetchCacheISR.js";
+import { patchFetchCacheSetMissingWaitUntil } from "./patch/patchFetchCacheWaitUntil.js";
+export async function createServerBundle(options, codeCustomization) {
     const { config } = options;
     const foundRoutes = new Set();
     // Get all functions to build
@@ -29,7 +33,7 @@ export async function createServerBundle(options) {
             await generateEdgeBundle(name, options, fnOptions);
         }
         else {
-            await generateBundle(name, options, fnOptions);
+            await generateBundle(name, options, fnOptions, codeCustomization);
         }
     });
     //TODO: throw an error if not all edge runtime routes has been bundled in a separate function
@@ -67,7 +71,7 @@ export async function createServerBundle(options) {
         patterns: ["*"],
     });
 }
-async function generateBundle(name, options, fnOptions) {
+async function generateBundle(name, options, fnOptions, codeCustomization) {
     const { appPath, appBuildOutputPath, config, outputDir, monorepoRoot } = options;
     logger.info(`Building server function: ${name}...`);
     // Create output folder
@@ -100,23 +104,35 @@ async function generateBundle(name, options, fnOptions) {
     // Copy env files
     buildHelper.copyEnvFile(appBuildOutputPath, packagePath, outputPath);
     // Copy all necessary traced files
-    await copyTracedFiles({
+    const { tracedFiles, manifests } = await copyTracedFiles({
         buildOutputPath: appBuildOutputPath,
         packagePath,
         outputDir: outputPath,
         routes: fnOptions.routes ?? ["app/page.tsx"],
         bundledNextServer: isBundled,
     });
+    const additionalCodePatches = codeCustomization?.additionalCodePatches ?? [];
+    await applyCodePatches(options, tracedFiles, manifests, [
+        patchFetchCacheSetMissingWaitUntil,
+        patchFetchCacheForISR,
+        patchUnstableCacheForISR,
+        ...additionalCodePatches,
+    ]);
     // Build Lambda code
     // note: bundle in OpenNext package b/c the adapter relies on the
     //       "serverless-http" package which is not a dependency in user's
     //       Next.js app.
-    const disableNextPrebundledReact = buildHelper.compareSemver(options.nextVersion, "13.5.1") >= 0 ||
-        buildHelper.compareSemver(options.nextVersion, "13.4.1") <= 0;
+    const disableNextPrebundledReact = buildHelper.compareSemver(options.nextVersion, ">=", "13.5.1") ||
+        buildHelper.compareSemver(options.nextVersion, "<=", "13.4.1");
     const overrides = fnOptions.override ?? {};
-    const isBefore13413 = buildHelper.compareSemver(options.nextVersion, "13.4.13") <= 0;
-    const isAfter141 = buildHelper.compareSemver(options.nextVersion, "14.1") >= 0;
+    const isBefore13413 = buildHelper.compareSemver(options.nextVersion, "<=", "13.4.13");
+    const isAfter141 = buildHelper.compareSemver(options.nextVersion, ">=", "14.1");
+    const isAfter142 = buildHelper.compareSemver(options.nextVersion, ">=", "14.2");
     const disableRouting = isBefore13413 || config.middleware?.external;
+    const updater = new ContentUpdater(options);
+    const additionalPlugins = codeCustomization?.additionalPlugins
+        ? codeCustomization.additionalPlugins(updater)
+        : [];
     const plugins = [
         openNextReplacementPlugin({
             name: `requestHandlerOverride ${name}`,
@@ -124,6 +140,7 @@ async function generateBundle(name, options, fnOptions) {
             deletes: [
                 ...(disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : []),
                 ...(disableRouting ? ["withRouting"] : []),
+                ...(isAfter142 ? ["patchAsyncStorage"] : []),
             ],
         }),
         openNextReplacementPlugin({
@@ -141,6 +158,9 @@ async function generateBundle(name, options, fnOptions) {
             fnName: name,
             overrides,
         }),
+        ...additionalPlugins,
+        // The content updater plugin must be the last plugin
+        updater.plugin,
     ];
     const outfileExt = fnOptions.runtime === "deno" ? "ts" : "mjs";
     await buildHelper.esbuildAsync({

package/dist/build/edge/createEdgeBundle.d.ts

@@ -1,6 +1,8 @@
+import { type Plugin } from "esbuild";
 import type { MiddlewareInfo } from "../../types/next-types";
 import type { IncludedConverter, IncludedOriginResolver, LazyLoadedOverride, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
 import type { OriginResolver } from "../../types/overrides.js";
+import { ContentUpdater } from "../../plugins/content-updater.js";
 import { type BuildOptions } from "../helper.js";
 type Override = OverrideOptions & {
     originResolver?: LazyLoadedOverride<OriginResolver> | IncludedOriginResolver;
@@ -17,7 +19,8 @@ interface BuildEdgeBundleOptions {
     additionalExternals?: string[];
     onlyBuildOnce?: boolean;
     name: string;
+    additionalPlugins?: (contentUpdater: ContentUpdater) => Plugin[];
 }
-export declare function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, name, }: BuildEdgeBundleOptions): Promise<void>;
-export declare function generateEdgeBundle(name: string, options: BuildOptions, fnOptions: SplittedFunctionOptions): Promise<void>;
+export declare function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, name, additionalPlugins: additionalPluginsFn, }: BuildEdgeBundleOptions): Promise<void>;
+export declare function generateEdgeBundle(name: string, options: BuildOptions, fnOptions: SplittedFunctionOptions, additionalPlugins?: (contentUpdater: ContentUpdater) => Plugin[]): Promise<void>;
 export {};

package/dist/build/edge/createEdgeBundle.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { build } from "esbuild";
 import { loadMiddlewareManifest } from "../../adapters/config/util.js";
 import logger from "../../logger.js";
+import { ContentUpdater } from "../../plugins/content-updater.js";
 import { openNextEdgePlugins } from "../../plugins/edge.js";
 import { openNextExternalMiddlewarePlugin } from "../../plugins/externalMiddleware.js";
 import { openNextReplacementPlugin } from "../../plugins/replacement.js";
@@ -11,13 +12,17 @@ import { openNextResolvePlugin } from "../../plugins/resolve.js";
 import { getCrossPlatformPathRegex } from "../../utils/regex.js";
 import { isEdgeRuntime } from "../helper.js";
 import { copyOpenNextConfig, esbuildAsync } from "../helper.js";
-export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, name, }) {
+export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, name, additionalPlugins: additionalPluginsFn, }) {
     const isInCloudfare = await isEdgeRuntime(overrides);
     function override(target) {
         return typeof overrides?.[target] === "string"
             ? overrides[target]
             : undefined;
     }
+    const contentUpdater = new ContentUpdater(options);
+    const additionalPlugins = additionalPluginsFn
+        ? additionalPluginsFn(contentUpdater)
+        : [];
     await esbuildAsync({
         entryPoints: [entrypoint],
         bundle: true,
@@ -53,6 +58,9 @@ export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, opt
                 nextDir: path.join(options.appBuildOutputPath, ".next"),
                 isInCloudfare,
             }),
+            ...additionalPlugins,
+            // The content updater plugin must be the last plugin
+            contentUpdater.plugin,
         ],
         treeShaking: true,
         alias: {
@@ -117,7 +125,7 @@ Object.defineProperty = function(o, p, a) {
         });
     }
 }
-export async function generateEdgeBundle(name, options, fnOptions) {
+export async function generateEdgeBundle(name, options, fnOptions, additionalPlugins = () => []) {
     logger.info(`Generating edge bundle for: ${name}`);
     const buildOutputDotNextDir = path.join(options.appBuildOutputPath, ".next");
     // Create output folder
@@ -153,5 +161,6 @@ export async function generateEdgeBundle(name, options, fnOptions) {
         overrides: fnOptions.override,
         additionalExternals: options.config.edgeExternals,
         name,
+        additionalPlugins,
     });
 }

package/dist/build/helper.d.ts

@@ -51,15 +51,16 @@ 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("1.0.0", "1.0.0") // 0
+ *     compareSemver("2.0.0", ">=", "1.0.0") === true
  */
-export declare function compareSemver(v1: string, v2: string): number;
+export declare function compareSemver(v1: string, operator: SemverOp, v2: string): boolean;
 export declare function copyOpenNextConfig(inputDir: string, outputDir: string, isEdge?: boolean): void;
 export declare function copyEnvFile(appPath: string, packagePath: string, outputPath: string): void;
 /**

package/dist/build/helper.js

@@ -213,29 +213,54 @@ export function getNextVersion(appPath) {
  * @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("1.0.0", "1.0.0") // 0
+ *     compareSemver("2.0.0", ">=", "1.0.0") === true
  */
-export function compareSemver(v1, v2) {
-    if (v1 === "latest")
-        return 1;
-    if (/^[^\d]/.test(v1)) {
-        // biome-ignore lint/style/noParameterAssign:
-        v1 = v1.substring(1);
+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;
     }
-    if (/^[^\d]/.test(v2)) {
-        // biome-ignore lint/style/noParameterAssign:
-        v2 = v2.substring(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;
+        }
     }
-    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.");
+    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}`);
     }
-    if (major1 !== major2)
-        return major1 - major2;
-    if (minor1 !== minor2)
-        return minor1 - minor2;
-    return patch1 - patch2;
 }
 export function copyOpenNextConfig(inputDir, outputDir, isEdge = false) {
     // Copy open-next.config.mjs

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

@@ -0,0 +1,58 @@
+import { type Edit, Lang, type NapiConfig, type SgNode } from "@ast-grep/napi";
+import type { PatchCodeFn } from "./codePatcher";
+export type * from "@ast-grep/napi";
+/**
+ * fix has the same meaning as in yaml rules
+ * see https://ast-grep.github.io/guide/rewrite-code.html#using-fix-in-yaml-rule
+ */
+export type RuleConfig = NapiConfig & {
+    fix?: string;
+};
+/**
+ * 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.
+ *
+ * @param rule The rule. Either a yaml string or an instance of `RuleConfig`
+ * @param root The root node
+ * @param once only apply once
+ * @returns A list of edits and a list of matches.
+ */
+export declare function applyRule(rule: string | RuleConfig, root: SgNode, { once }?: {
+    once?: boolean | undefined;
+}): {
+    edits: Edit[];
+    matches: SgNode[];
+};
+/**
+ * Parse a file and obtain its root.
+ *
+ * @param path The file path
+ * @param lang The language to parse. Defaults to TypeScript.
+ * @returns The root for the file.
+ */
+export declare function parseFile(path: string, lang?: Lang): SgNode;
+/**
+ * Patches the code from by applying the rule.
+ *
+ * This function is mainly for on off edits and tests,
+ * use `getRuleEdits` to apply multiple rules.
+ *
+ * @param code The source code
+ * @param rule The astgrep rule (yaml or NapiConfig)
+ * @param lang The language used by the source code
+ * @param lang Whether to apply the rule only once
+ * @returns The patched code
+ */
+export declare function patchCode(code: string, rule: string | RuleConfig, { lang, once }?: {
+    lang?: Lang | undefined;
+    once?: boolean | undefined;
+}): string;
+/**
+ * @param rule
+ * @param lang
+ * @returns a callback applying the the rule.
+ */
+export declare function createPatchCode(rule: string | RuleConfig, lang?: Lang): PatchCodeFn;

package/dist/build/patch/astCodePatcher.js

@@ -0,0 +1,76 @@
+// Mostly copied from the cloudflare adapter
+import { readFileSync } from "node:fs";
+import { Lang, parse, } from "@ast-grep/napi";
+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.
+ *
+ * @param rule The rule. Either a yaml string or an instance of `RuleConfig`
+ * @param root The root node
+ * @param once only apply once
+ * @returns A list of edits and a list of matches.
+ */
+export function applyRule(rule, root, { once = false } = {}) {
+    const ruleConfig = typeof rule === "string" ? yaml.parse(rule) : rule;
+    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)));
+    });
+    return { edits, matches };
+}
+/**
+ * Parse a file and obtain its root.
+ *
+ * @param path The file path
+ * @param lang The language to parse. Defaults to TypeScript.
+ * @returns The root for the file.
+ */
+export function parseFile(path, lang = Lang.TypeScript) {
+    return parse(lang, readFileSync(path, { encoding: "utf-8" })).root();
+}
+/**
+ * Patches the code from by applying the rule.
+ *
+ * This function is mainly for on off edits and tests,
+ * use `getRuleEdits` to apply multiple rules.
+ *
+ * @param code The source code
+ * @param rule The astgrep rule (yaml or NapiConfig)
+ * @param lang The language used by the source code
+ * @param lang Whether to apply the rule only once
+ * @returns The patched code
+ */
+export function patchCode(code, rule, { lang = Lang.TypeScript, once = false } = {}) {
+    const node = parse(lang, code).root();
+    const { edits } = applyRule(rule, node, { once });
+    return node.commitEdits(edits);
+}
+/**
+ * @param rule
+ * @param lang
+ * @returns a callback applying the the rule.
+ */
+export function createPatchCode(rule, lang = Lang.TypeScript) {
+    return async ({ code }) => patchCode(code, rule, { lang });
+}

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

@@ -0,0 +1,46 @@
+import type { getManifests } from "../copyTracedFiles.js";
+import * as buildHelper from "../helper.js";
+type Versions = `>=${number}.${number}.${number} <=${number}.${number}.${number}` | `>=${number}.${number}.${number}` | `<=${number}.${number}.${number}`;
+export interface VersionedField<T> {
+    /**
+     * The versions of Next.js that this field should be used for
+     * Should be in the format `">=16.0.0 <=17.0.0"` or `">=16.0.0"` or `"<=17.0.0"`
+     * **Be careful with spaces**
+     */
+    versions?: Versions;
+    field: T;
+}
+export type PatchCodeFn = (args: {
+    /**
+     * The code of the file that needs to be patched
+     */
+    code: string;
+    /**
+     * The final path of the file that needs to be patched
+     */
+    filePath: string;
+    /**
+     * All files that are traced and will be included in the bundle
+     */
+    tracedFiles: string[];
+    /**
+     * Next.js manifests that are used by Next at runtime
+     */
+    manifests: ReturnType<typeof getManifests>;
+}) => Promise<string>;
+interface IndividualPatch {
+    pathFilter: RegExp;
+    contentFilter?: RegExp;
+    patchCode: PatchCodeFn;
+}
+export interface CodePatcher {
+    name: string;
+    patches: IndividualPatch | VersionedField<IndividualPatch>[];
+}
+export declare function parseVersions(versions?: Versions): {
+    before?: string;
+    after?: string;
+};
+export declare function extractVersionedField<T>(fields: VersionedField<T>[], version: string): T[];
+export declare function applyCodePatches(buildOptions: buildHelper.BuildOptions, tracedFiles: string[], manifests: ReturnType<typeof getManifests>, codePatcher: CodePatcher[]): Promise<void>;
+export {};

package/dist/build/patch/codePatcher.js

@@ -0,0 +1,119 @@
+import * as fs from "node:fs/promises";
+import logger from "../../logger.js";
+import * as buildHelper from "../helper.js";
+export function parseVersions(versions) {
+    if (!versions) {
+        return {};
+    }
+    // We need to use regex to extract the versions
+    const versionRegex = /([<>]=)(\d+\.\d+\.\d+)/g;
+    const matches = Array.from(versions.matchAll(versionRegex));
+    if (matches.length === 0) {
+        throw new Error("Invalid version range, no matches found");
+    }
+    if (matches.length > 2) {
+        throw new Error("Invalid version range, too many matches found");
+    }
+    let after;
+    let before;
+    for (const match of matches) {
+        const [_, operator, version] = match;
+        if (operator === "<=") {
+            before = version;
+        }
+        else {
+            after = version;
+        }
+    }
+    // Before returning we reconstruct the version string and compare it to the original
+    // If they don't match we throw an error
+    // We have to do this because template literal types here seems to allow for extra spaces
+    // that could easily break the version comparison and allow some patch to be applied on incorrect versions
+    // This might even go unnoticed
+    const reconstructedVersion = `${after ? `>=${after}` : ""}${before ? `${after ? " " : ""}<=${before}` : ""}`;
+    if (reconstructedVersion !== versions) {
+        throw new Error("Invalid version range, the reconstructed version does not match the original");
+    }
+    return {
+        before,
+        after,
+    };
+}
+export function extractVersionedField(fields, version) {
+    const result = [];
+    for (const field of fields) {
+        // No versions specified, the patch always apply
+        if (!field.versions) {
+            result.push(field.field);
+            continue;
+        }
+        const { before, after } = parseVersions(field.versions);
+        // range
+        if (before && after) {
+            if (buildHelper.compareSemver(version, "<=", before) &&
+                buildHelper.compareSemver(version, ">=", after)) {
+                result.push(field.field);
+            }
+            continue;
+        }
+        // before only
+        if (before) {
+            if (buildHelper.compareSemver(version, "<=", before)) {
+                result.push(field.field);
+            }
+            continue;
+        }
+        // after only
+        if (after) {
+            if (buildHelper.compareSemver(version, ">=", after)) {
+                result.push(field.field);
+            }
+        }
+    }
+    return result;
+}
+export async function applyCodePatches(buildOptions, tracedFiles, manifests, codePatcher) {
+    const nextVersion = buildOptions.nextVersion;
+    logger.time("Applying code patches");
+    // We first filter against the version
+    // We also flatten the array of patches so that we get both the name and all the necessary patches
+    const patchesToApply = codePatcher.flatMap(({ name, patches }) => Array.isArray(patches)
+        ? extractVersionedField(patches, nextVersion).map((patch) => ({
+            name,
+            patch,
+        }))
+        : [{ name, patch: patches }]);
+    await Promise.all(tracedFiles.map(async (filePath) => {
+        // We check the filename against the filter to see if we should apply the patch
+        const patchMatchingPath = patchesToApply.filter(({ patch }) => {
+            return filePath.match(patch.pathFilter);
+        });
+        if (patchMatchingPath.length === 0) {
+            return;
+        }
+        const content = await fs.readFile(filePath, "utf-8");
+        // We filter a last time against the content this time
+        const patchToApply = patchMatchingPath.filter(({ patch }) => {
+            if (!patch.contentFilter) {
+                return true;
+            }
+            return content.match(patch.contentFilter);
+        });
+        if (patchToApply.length === 0) {
+            return;
+        }
+        // We apply the patches
+        let patchedContent = content;
+        for (const { patch, name } of patchToApply) {
+            logger.debug(`Applying code patch: ${name} to ${filePath}`);
+            patchedContent = await patch.patchCode({
+                code: patchedContent,
+                filePath,
+                tracedFiles,
+                manifests,
+            });
+        }
+        await fs.writeFile(filePath, patchedContent);
+    }));
+    logger.timeEnd("Applying code patches");
+}

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

@@ -0,0 +1,5 @@
+import type { CodePatcher } from "./codePatcher";
+export declare const fetchRule = "\nrule:\n  kind: member_expression\n  pattern: $WORK_STORE.isOnDemandRevalidate\n  inside:\n    kind: ternary_expression\n    all:\n      - has: {kind: 'null'}\n      - has: \n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n    inside:\n        kind: variable_declarator\n\nfix:\n  ($WORK_STORE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
+export declare const unstable_cacheRule = "\nrule:\n  kind: member_expression\n  pattern: $STORE_OR_CACHE.isOnDemandRevalidate\n  inside:\n    kind: if_statement\n    stopBy: end\n    has:\n      kind: statement_block\n      has:\n        kind: variable_declarator\n        has: \n          kind: await_expression\n          has:\n            kind: call_expression\n            all:\n              - has:\n                  kind: member_expression\n                  has:\n                    kind: property_identifier\n                    field: property\n                    regex: get\n              - has:\n                  kind: arguments\n                  has:\n                    kind: object\n                    has:\n                      kind: pair\n                      all:\n                        - has:\n                            kind: property_identifier\n                            field: key\n                            regex: softTags\n        stopBy: end\nfix:\n  ($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)\n";
+export declare const patchFetchCacheForISR: CodePatcher;
+export declare const patchUnstableCacheForISR: CodePatcher;

package/dist/build/patch/patchFetchCacheISR.js

@@ -0,0 +1,102 @@
+import { Lang } from "@ast-grep/napi";
+import { getCrossPlatformPathRegex } from "../../utils/regex.js";
+import { createPatchCode } from "./astCodePatcher.js";
+export const fetchRule = `
+rule:
+  kind: member_expression
+  pattern: $WORK_STORE.isOnDemandRevalidate
+  inside:
+    kind: ternary_expression
+    all:
+      - has: {kind: 'null'}
+      - has: 
+          kind: await_expression
+          has:
+            kind: call_expression
+            all:
+              - has:
+                  kind: member_expression
+                  has:
+                    kind: property_identifier
+                    field: property
+                    regex: get
+              - has:
+                  kind: arguments
+                  has:
+                    kind: object
+                    has:
+                      kind: pair
+                      all:
+                        - has:
+                            kind: property_identifier
+                            field: key
+                            regex: softTags
+    inside:
+        kind: variable_declarator
+
+fix:
+  ($WORK_STORE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)
+`;
+export const unstable_cacheRule = `
+rule:
+  kind: member_expression
+  pattern: $STORE_OR_CACHE.isOnDemandRevalidate
+  inside:
+    kind: if_statement
+    stopBy: end
+    has:
+      kind: statement_block
+      has:
+        kind: variable_declarator
+        has: 
+          kind: await_expression
+          has:
+            kind: call_expression
+            all:
+              - has:
+                  kind: member_expression
+                  has:
+                    kind: property_identifier
+                    field: property
+                    regex: get
+              - has:
+                  kind: arguments
+                  has:
+                    kind: object
+                    has:
+                      kind: pair
+                      all:
+                        - has:
+                            kind: property_identifier
+                            field: key
+                            regex: softTags
+        stopBy: end
+fix:
+  ($STORE_OR_CACHE.isOnDemandRevalidate && !globalThis.__openNextAls?.getStore()?.isISRRevalidation)
+`;
+export const patchFetchCacheForISR = {
+    name: "patch-fetch-cache-for-isr",
+    patches: [
+        {
+            versions: ">=14.0.0",
+            field: {
+                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|patch-fetch\.js)$`, { escape: false }),
+                contentFilter: /\.isOnDemandRevalidate/,
+                patchCode: createPatchCode(fetchRule, Lang.JavaScript),
+            },
+        },
+    ],
+};
+export const patchUnstableCacheForISR = {
+    name: "patch-unstable-cache-for-isr",
+    patches: [
+        {
+            versions: ">=14.2.0",
+            field: {
+                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|spec-extension/unstable-cache\.js)$`, { escape: false }),
+                contentFilter: /\.isOnDemandRevalidate/,
+                patchCode: createPatchCode(unstable_cacheRule, Lang.JavaScript),
+            },
+        },
+    ],
+};

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

@@ -0,0 +1,3 @@
+import type { CodePatcher } from "./codePatcher";
+export declare const rule = "\nrule:\n  kind: call_expression\n  pattern: $PROMISE\n  all:\n    - has: { pattern: $_.arrayBuffer().then, stopBy: end }\n    - has: { pattern: \"Buffer.from\", stopBy: end }\n    - any:\n        - inside:\n            kind: sequence_expression\n            inside:\n                kind: return_statement\n        - inside:\n            kind: expression_statement\n            precedes:\n                kind: return_statement\n    - has: { pattern: $_.FETCH, stopBy: end }\n\nfix: |\n  globalThis.__openNextAls?.getStore()?.pendingPromiseRunner.add($PROMISE)\n";
+export declare const patchFetchCacheSetMissingWaitUntil: CodePatcher;

package/dist/build/patch/patchFetchCacheWaitUntil.js

@@ -0,0 +1,36 @@
+import { getCrossPlatformPathRegex } from "../../utils/regex.js";
+import { createPatchCode } from "./astCodePatcher.js";
+export const rule = `
+rule:
+  kind: call_expression
+  pattern: $PROMISE
+  all:
+    - has: { pattern: $_.arrayBuffer().then, stopBy: end }
+    - has: { pattern: "Buffer.from", stopBy: end }
+    - any:
+        - inside:
+            kind: sequence_expression
+            inside:
+                kind: return_statement
+        - inside:
+            kind: expression_statement
+            precedes:
+                kind: return_statement
+    - has: { pattern: $_.FETCH, stopBy: end }
+
+fix: |
+  globalThis.__openNextAls?.getStore()?.pendingPromiseRunner.add($PROMISE)
+`;
+export const patchFetchCacheSetMissingWaitUntil = {
+    name: "patch-fetch-cache-set-missing-wait-until",
+    patches: [
+        {
+            versions: ">=15.0.0",
+            field: {
+                pathFilter: getCrossPlatformPathRegex(String.raw `(server/chunks/.*\.js|.*\.runtime\..*\.js|patch-fetch\.js)$`, { escape: false }),
+                contentFilter: /arrayBuffer\(\)\s*\.then/,
+                patchCode: createPatchCode(rule),
+            },
+        },
+    ],
+};

package/dist/core/requestHandler.js

@@ -9,7 +9,9 @@ import routingHandler, { INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_R
 import { requestHandler, setNextjsPrebundledReact } from "./util";
 // This is used to identify requests in the cache
 globalThis.__openNextAls = new AsyncLocalStorage();
+//#override patchAsyncStorage
 patchAsyncStorage();
+//#endOverride
 export async function openNextHandler(internalEvent, options) {
     const initialHeaders = internalEvent.headers;
     // We run everything in the async local storage context so that it is available in the middleware as well as in NextServer
@@ -94,7 +96,7 @@ export async function openNextHandler(internalEvent, options) {
                     resolvedRoutes: [],
                     origin: false,
                     initialURL: internalEvent.url,
-                }, headers, options.streamCreator);
+                }, routingResult.headers, options.streamCreator);
                 response.statusCode = routingResult.statusCode;
                 response.flushHeaders();
                 const [bodyToConsume, bodyToReturn] = routingResult.body.tee();

package/dist/core/routing/cacheInterceptor.js

@@ -48,7 +48,12 @@ async function computeCacheControl(path, body, host, revalidate, lastModified) {
                 url = `${NextConfig.basePath}${url}`;
             }
             await globalThis.queue.send({
-                MessageBody: { host, url },
+                MessageBody: {
+                    host,
+                    url,
+                    eTag: etag,
+                    lastModified: lastModified ?? Date.now(),
+                },
                 MessageDeduplicationId: hash(`${path}-${lastModified}-${etag}`),
                 MessageGroupId: generateMessageGroupId(path),
             });

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

@@ -3,12 +3,12 @@ import type { InternalEvent, InternalResult } from "../../types/open-next";
 export declare function getNextConfigHeaders(event: InternalEvent, configHeaders?: Header[] | undefined): Record<string, string | undefined>;
 export declare function handleRewrites<T extends RewriteDefinition>(event: InternalEvent, rewrites: T[]): {
     internalEvent: {
+        query: Record<string, string | string[]>;
         rawPath: string;
         url: string;
         method: string;
         body?: Buffer;
         headers: Record<string, string>;
-        query: Record<string, string | string[]>;
         cookies: Record<string, string>;
         remoteAddress: string;
         type: "core";

package/dist/core/routing/matcher.js

@@ -145,10 +145,17 @@ export function handleRewrites(event, rewrites) {
             rewrittenHost = unescapeRegex(toDestinationHost(params));
             rewrittenQuery = unescapeRegex(toDestinationQuery(params));
         }
+        // We need to strip the locale from the path if it's a local api route
+        if (NextConfig.i18n && !isExternalRewrite) {
+            const strippedPathLocale = rewrittenPath.replace(new RegExp(`^/(${NextConfig.i18n.locales.join("|")})`), "");
+            if (strippedPathLocale.startsWith("/api/")) {
+                rewrittenPath = strippedPathLocale;
+            }
+        }
         rewrittenUrl = isExternalRewrite
             ? `${protocol}//${rewrittenHost}${rewrittenPath}`
             : new URL(rewrittenPath, event.url).href;
-        // Should we merge the query params or use only the ones from the rewrite?
+        // We merge query params from the source and the destination
         finalQuery = {
             ...query,
             ...convertFromQueryString(rewrittenQuery),
@@ -159,6 +166,7 @@ export function handleRewrites(event, rewrites) {
     return {
         internalEvent: {
             ...event,
+            query: finalQuery,
             rawPath: new URL(rewrittenUrl).pathname,
             url: rewrittenUrl,
         },

package/dist/core/routing/middleware.js

@@ -73,6 +73,12 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     const reqHeaders = {};
     const resHeaders = {};
     responseHeaders.delete("x-middleware-override-headers");
+    /*  Next will set the header `x-middleware-set-cookie` when you `set-cookie` in the middleware.
+     *  We can delete it here since it will be set in `set-cookie` aswell. Next removes this header in the response themselves.
+     * `x-middleware-next` is set when you invoke `NextResponse.next()`. We can delete it here aswell.
+     */
+    responseHeaders.delete("x-middleware-set-cookie");
+    responseHeaders.delete("x-middleware-next");
     const xMiddlewareKey = "x-middleware-request-";
     responseHeaders.forEach((value, key) => {
         if (key.startsWith(xMiddlewareKey)) {

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

@@ -1 +1,2 @@
+export declare function generateShardId(rawPath: string, maxConcurrency: number, prefix: string): string;
 export declare function generateMessageGroupId(rawPath: string): string;

package/dist/core/routing/queue.js

@@ -1,3 +1,14 @@
+export function generateShardId(rawPath, maxConcurrency, prefix) {
+    let a = cyrb128(rawPath);
+    // We use mulberry32 to generate a random int between 0 and MAX_REVALIDATE_CONCURRENCY
+    let t = (a += 0x6d2b79f5);
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    const randomFloat = ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    // This will generate a random int between 0 and maxConcurrency
+    const randomInt = Math.floor(randomFloat * maxConcurrency);
+    return `${prefix}-${randomInt}`;
+}
 // Since we're using a FIFO queue, every messageGroupId is treated sequentially
 // This could cause a backlog of messages in the queue if there is too much page to
 // revalidate at once. To avoid this, we generate a random messageGroupId for each
@@ -6,17 +17,10 @@
 // will always have the same messageGroupId.
 // https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript#answer-47593316
 export function generateMessageGroupId(rawPath) {
-    let a = cyrb128(rawPath);
-    // We use mulberry32 to generate a random int between 0 and MAX_REVALIDATE_CONCURRENCY
-    let t = (a += 0x6d2b79f5);
-    t = Math.imul(t ^ (t >>> 15), t | 1);
-    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-    const randomFloat = ((t ^ (t >>> 14)) >>> 0) / 4294967296;
     // This will generate a random int between 0 and MAX_REVALIDATE_CONCURRENCY
     // This means that we could have 1000 revalidate request at the same time
     const maxConcurrency = Number.parseInt(process.env.MAX_REVALIDATE_CONCURRENCY ?? "10");
-    const randomInt = Math.floor(randomFloat * maxConcurrency);
-    return `revalidate-${randomInt}`;
+    return generateShardId(rawPath, maxConcurrency, "revalidate");
 }
 // Used to generate a hash int from a string
 function cyrb128(str) {

package/dist/core/routing/util.js

@@ -268,10 +268,10 @@ export async function revalidateIfRequired(host, rawPath, headers, req) {
             const lastModified = globalThis.__openNextAls.getStore()?.lastModified ?? 0;
             // For some weird cases, lastModified is not set, haven't been able to figure out yet why
             // For those cases we add the etag to the deduplication id, it might help
-            const etag = headers.etag ?? headers.ETag ?? "";
+            const eTag = `${headers.etag ?? headers.ETag ?? ""}`;
             await globalThis.queue.send({
-                MessageBody: { host, url: revalidateUrl },
-                MessageDeduplicationId: hash(`${rawPath}-${lastModified}-${etag}`),
+                MessageBody: { host, url: revalidateUrl, eTag, lastModified },
+                MessageDeduplicationId: hash(`${rawPath}-${lastModified}-${eTag}`),
                 MessageGroupId: generateMessageGroupId(rawPath),
             });
         }

package/dist/logger.d.ts

@@ -8,5 +8,13 @@ declare const _default: {
     };
     warn: (...args: any[]) => void;
     error: (...args: any[]) => void;
+    time: {
+        (label?: string): void;
+        (label?: string): void;
+    };
+    timeEnd: {
+        (label?: string): void;
+        (label?: string): void;
+    };
 };
 export default _default;

package/dist/logger.js

@@ -10,4 +10,6 @@ export default {
     info: console.log,
     warn: (...args) => console.warn(chalk.yellow("WARN"), ...args),
     error: (...args) => console.error(chalk.red("ERROR"), ...args),
+    time: console.time,
+    timeEnd: console.timeEnd,
 };

package/dist/overrides/wrappers/express-dev.js

@@ -19,7 +19,9 @@ const wrapper = async (handler, converter) => {
         const internalEvent = await converter.convertFrom(req);
         const streamCreator = {
             writeHeaders: (prelude) => {
+                res.setHeader("Set-Cookie", prelude.cookies);
                 res.writeHead(prelude.statusCode, prelude.headers);
+                res.flushHeaders();
                 return res;
             },
             onFinish: () => { },

package/dist/plugins/content-updater.d.ts

@@ -0,0 +1,48 @@
+/**
+ * ESBuild stops calling `onLoad` hooks after the first hook returns an updated content.
+ *
+ * The updater allows multiple plugins to update the content.
+ */
+import type { OnLoadOptions, Plugin, PluginBuild } from "esbuild";
+import type { BuildOptions } from "../build/helper";
+import { type VersionedField } from "../build/patch/codePatcher.js";
+export type * from "esbuild";
+/**
+ * The callbacks returns either an updated content or undefined if the content is unchanged.
+ */
+export type Callback = (args: {
+    contents: string;
+    path: string;
+}) => string | undefined | Promise<string | undefined>;
+/**
+ * The callback is called only when `contentFilter` matches the content.
+ * It can be used as a fast heuristic to prevent an expensive update.
+ */
+export type OnUpdateOptions = OnLoadOptions & {
+    contentFilter: RegExp;
+};
+export type Updater = OnUpdateOptions & {
+    callback: Callback;
+};
+export declare class ContentUpdater {
+    private buildOptions;
+    updaters: Map<string, Updater[]>;
+    constructor(buildOptions: BuildOptions);
+    /**
+     * Register a callback to update the file content.
+     *
+     * The callbacks are called in order of registration.
+     *
+     * @param name The name of the plugin (must be unique).
+     * @param updater A versioned field with the callback and `OnUpdateOptions`.
+     * @returns A noop ESBuild plugin.
+     */
+    updateContent(name: string, versionedUpdaters: VersionedField<Updater>[]): Plugin;
+    /**
+     * Returns an ESBuild plugin applying the registered updates.
+     */
+    get plugin(): {
+        name: string;
+        setup: (build: PluginBuild) => Promise<void>;
+    };
+}

package/dist/plugins/content-updater.js

@@ -0,0 +1,65 @@
+/**
+ * ESBuild stops calling `onLoad` hooks after the first hook returns an updated content.
+ *
+ * The updater allows multiple plugins to update the content.
+ */
+import { readFile } from "node:fs/promises";
+import { extractVersionedField, } from "../build/patch/codePatcher.js";
+export class ContentUpdater {
+    buildOptions;
+    updaters = new Map();
+    constructor(buildOptions) {
+        this.buildOptions = buildOptions;
+    }
+    /**
+     * Register a callback to update the file content.
+     *
+     * The callbacks are called in order of registration.
+     *
+     * @param name The name of the plugin (must be unique).
+     * @param updater A versioned field with the callback and `OnUpdateOptions`.
+     * @returns A noop ESBuild plugin.
+     */
+    updateContent(name, versionedUpdaters) {
+        if (this.updaters.has(name)) {
+            throw new Error(`Plugin "${name}" already registered`);
+        }
+        const updaters = extractVersionedField(versionedUpdaters, this.buildOptions.nextVersion);
+        this.updaters.set(name, updaters);
+        return {
+            name,
+            setup() { },
+        };
+    }
+    /**
+     * Returns an ESBuild plugin applying the registered updates.
+     */
+    get plugin() {
+        return {
+            name: "aggregate-on-load",
+            setup: async (build) => {
+                build.onLoad({ filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/ }, async (args) => {
+                    const updaters = Array.from(this.updaters.values()).flat();
+                    if (updaters.length === 0) {
+                        return;
+                    }
+                    let contents = await readFile(args.path, "utf-8");
+                    for (const { filter, namespace, contentFilter, callback, } of updaters) {
+                        if (namespace !== undefined && args.namespace !== namespace) {
+                            continue;
+                        }
+                        if (!args.path.match(filter)) {
+                            continue;
+                        }
+                        if (!contents.match(contentFilter)) {
+                            continue;
+                        }
+                        contents =
+                            (await callback({ contents, path: args.path })) ?? contents;
+                    }
+                    return { contents };
+                });
+            },
+        };
+    }
+}

package/dist/types/overrides.d.ts

@@ -6,6 +6,8 @@ export interface QueueMessage {
     MessageBody: {
         host: string;
         url: string;
+        lastModified: number;
+        eTag: string;
     };
     MessageGroupId: string;
 }

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.5.1",
+  "version": "3.5.3",
   "bin": {
     "open-next": "./dist/index.js"
   },
@@ -33,6 +33,7 @@
     "README.md"
   ],
   "dependencies": {
+    "@ast-grep/napi": "^0.35.0",
     "@aws-sdk/client-cloudfront": "3.398.0",
     "@aws-sdk/client-dynamodb": "^3.398.0",
     "@aws-sdk/client-lambda": "^3.398.0",
@@ -46,7 +47,8 @@
     "esbuild": "0.19.2",
     "express": "5.0.1",
     "path-to-regexp": "^6.3.0",
-    "urlpattern-polyfill": "^10.0.0"
+    "urlpattern-polyfill": "^10.0.0",
+    "yaml": "^2.7.0"
   },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.109",