@opennextjs/aws 3.5.3 → 3.5.5

package/dist/build/compileConfig.d.ts

@@ -6,10 +6,14 @@ import type { OpenNextConfig } from "../types/open-next.js";
  *
  * @param baseDir Directory where to look for the configuration.
  * @param openNextConfigPath Override the default configuration when provided. Relative to baseDir.
- * @param nodeExternals Externals for the Node.js compilation.
+ * @param nodeExternals Coma separated list of Externals for the Node.js compilation.
+ * @param compileEdge Force compiling for the edge runtime when true
  * @return The configuration and the build directory.
  */
-export declare function compileOpenNextConfig(baseDir: string, openNextConfigPath?: string, nodeExternals?: string): Promise<{
+export declare function compileOpenNextConfig(baseDir: string, openNextConfigPath?: string, { nodeExternals, compileEdge }?: {
+    nodeExternals?: string | undefined;
+    compileEdge?: boolean | undefined;
+}): Promise<{
     config: OpenNextConfig;
     buildDir: string;
 }>;

package/dist/build/compileConfig.js

@@ -11,13 +11,14 @@ import { validateConfig } from "./validateConfig.js";
  *
  * @param baseDir Directory where to look for the configuration.
  * @param openNextConfigPath Override the default configuration when provided. Relative to baseDir.
- * @param nodeExternals Externals for the Node.js compilation.
+ * @param nodeExternals Coma separated list of Externals for the Node.js compilation.
+ * @param compileEdge Force compiling for the edge runtime when true
  * @return The configuration and the build directory.
  */
-export async function compileOpenNextConfig(baseDir, openNextConfigPath, nodeExternals) {
+export async function compileOpenNextConfig(baseDir, openNextConfigPath, { nodeExternals = "", compileEdge = false } = {}) {
     const sourcePath = path.join(baseDir, openNextConfigPath ?? "open-next.config.ts");
     const buildDir = fs.mkdtempSync(path.join(os.tmpdir(), "open-next-tmp"));
-    let configPath = compileOpenNextConfigNode(sourcePath, buildDir, nodeExternals ? nodeExternals.split(",") : []);
+    let configPath = compileOpenNextConfigNode(sourcePath, buildDir, nodeExternals.split(","));
     // On Windows, we need to use file:// protocol to load the config file using import()
     if (process.platform === "win32")
         configPath = `file://${configPath}`;
@@ -31,12 +32,12 @@ export async function compileOpenNextConfig(baseDir, openNextConfigPath, nodeExt
     // If it does, we need to compile it with the edge runtime
     const usesEdgeRuntime = (config.middleware?.external && config.middleware.runtime !== "node") ||
         Object.values(config.functions || {}).some((fn) => fn.runtime === "edge");
-    if (!usesEdgeRuntime) {
-        logger.debug("No edge runtime found in the open-next.config.ts. Using default config.");
-        //Nothing to do here
+    if (usesEdgeRuntime || compileEdge) {
+        compileOpenNextConfigEdge(sourcePath, buildDir, config.edgeExternals ?? []);
     }
     else {
-        compileOpenNextConfigEdge(sourcePath, buildDir, config.edgeExternals ?? []);
+        // Skip compiling for the edge runtime.
+        logger.debug("No edge runtime found in the open-next.config.ts. Using default config.");
     }
     return { config, buildDir };
 }

package/dist/build/copyTracedFiles.js

@@ -55,12 +55,12 @@ export async function copyTracedFiles({ buildOutputPath, packagePath, outputDir,
         });
     }
     // create directory for pages
-    if (existsSync(path.join(standaloneServerDir, "pages"))) {
+    if (existsSync(path.join(standaloneNextDir, "server/pages"))) {
         mkdirSync(path.join(outputNextDir, "server/pages"), {
             recursive: true,
         });
     }
-    if (existsSync(path.join(standaloneServerDir, "app"))) {
+    if (existsSync(path.join(standaloneNextDir, "server/app"))) {
         mkdirSync(path.join(outputNextDir, "server/app"), {
             recursive: true,
         });
@@ -210,7 +210,7 @@ File ${fullFilePath} does not exist
     // Maybe even move this to s3 directly
     if (hasPageDir) {
         // First we get truly static files - i.e. pages without getStaticProps
-        const staticFiles = Object.values(JSON.parse(readFileSync(path.join(standaloneServerDir, "pages-manifest.json"), "utf8")));
+        const staticFiles = Object.values(loadPagesManifest(standaloneNextDir));
         // Then we need to get all fallback: true dynamic routes html
         const prerenderManifest = loadPrerenderManifest(standaloneNextDir);
         const config = loadConfig(standaloneNextDir);

package/dist/build/createMiddleware.js

@@ -58,6 +58,7 @@ export async function createMiddleware(options, { forceOnlyBuildOnce = false } =
             outfile: path.join(options.buildDir, "middleware.mjs"),
             middlewareInfo: edgeMiddlewareInfo,
             options,
+            overrides: config.default.override,
             onlyBuildOnce: true,
             name: "middleware",
         });

package/dist/build/createServerBundle.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { loadMiddlewareManifest } from "../adapters/config/util.js";
 import logger from "../logger.js";
 import { minifyAll } from "../minimize-js.js";
 import { ContentUpdater } from "../plugins/content-updater.js";
@@ -9,7 +10,7 @@ import { getCrossPlatformPathRegex } from "../utils/regex.js";
 import { bundleNextServer } from "./bundleNextServer.js";
 import { compileCache } from "./compileCache.js";
 import { copyTracedFiles } from "./copyTracedFiles.js";
-import { generateEdgeBundle } from "./edge/createEdgeBundle.js";
+import { copyMiddlewareResources, generateEdgeBundle, } from "./edge/createEdgeBundle.js";
 import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
 import { applyCodePatches } from "./patch/codePatcher.js";
@@ -82,25 +83,28 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
     //       `.next/standalone/package/path` (ie. `.next`, `server.js`).
     //       We need to output the handler file inside the package path.
     const packagePath = buildHelper.getPackagePath(options);
-    fs.mkdirSync(path.join(outputPath, packagePath), { recursive: true });
+    const outPackagePath = path.join(outputPath, packagePath);
+    fs.mkdirSync(outPackagePath, { recursive: true });
     const ext = fnOptions.runtime === "deno" ? "mjs" : "cjs";
-    fs.copyFileSync(path.join(options.buildDir, `cache.${ext}`), path.join(outputPath, packagePath, "cache.cjs"));
+    fs.copyFileSync(path.join(options.buildDir, `cache.${ext}`), path.join(outPackagePath, "cache.cjs"));
     if (fnOptions.runtime === "deno") {
         addDenoJson(outputPath, packagePath);
     }
     // Bundle next server if necessary
     const isBundled = fnOptions.experimentalBundledNextServer ?? false;
     if (isBundled) {
-        await bundleNextServer(path.join(outputPath, packagePath), appPath, {
+        await bundleNextServer(outPackagePath, appPath, {
             minify: options.minify,
         });
     }
     // Copy middleware
     if (!config.middleware?.external) {
-        fs.copyFileSync(path.join(options.buildDir, "middleware.mjs"), path.join(outputPath, packagePath, "middleware.mjs"));
+        fs.copyFileSync(path.join(options.buildDir, "middleware.mjs"), path.join(outPackagePath, "middleware.mjs"));
+        const middlewareManifest = loadMiddlewareManifest(path.join(options.appBuildOutputPath, ".next"));
+        copyMiddlewareResources(options, middlewareManifest.middleware["/"], outPackagePath);
     }
     // Copy open-next.config.mjs
-    buildHelper.copyOpenNextConfig(options.buildDir, path.join(outputPath, packagePath));
+    buildHelper.copyOpenNextConfig(options.buildDir, outPackagePath);
     // Copy env files
     buildHelper.copyEnvFile(appBuildOutputPath, packagePath, outputPath);
     // Copy all necessary traced files
@@ -233,7 +237,7 @@ function addMonorepoEntrypoint(outputPath, packagePath) {
     //       that re-exports the real handler.
     // Always use posix path for import path
     const packagePosixPath = packagePath.split(path.sep).join(path.posix.sep);
-    fs.writeFileSync(path.join(outputPath, "index.mjs"), `export * from "./${packagePosixPath}/index.mjs";`);
+    fs.writeFileSync(path.join(outputPath, "index.mjs"), `export { handler } from "./${packagePosixPath}/index.mjs";`);
 }
 async function minifyServerBundle(outputDir) {
     logger.info("Minimizing server function...");

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

@@ -23,4 +23,8 @@ interface BuildEdgeBundleOptions {
 }
 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>;
+/**
+ * Copy wasm files and assets into the destDir.
+ */
+export declare function copyMiddlewareResources(options: BuildOptions, middlewareInfo: MiddlewareInfo | undefined, destDir: string): void;
 export {};

package/dist/build/edge/createEdgeBundle.js

@@ -13,7 +13,7 @@ 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, additionalPlugins: additionalPluginsFn, }) {
-    const isInCloudfare = await isEdgeRuntime(overrides);
+    const isInCloudflare = await isEdgeRuntime(overrides);
     function override(target) {
         return typeof overrides?.[target] === "string"
             ? overrides[target]
@@ -56,7 +56,7 @@ export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, opt
             openNextEdgePlugins({
                 middlewareInfo,
                 nextDir: path.join(options.appBuildOutputPath, ".next"),
-                isInCloudfare,
+                isInCloudflare,
             }),
             ...additionalPlugins,
             // The content updater plugin must be the last plugin
@@ -97,7 +97,7 @@ Object.defineProperty = function(o, p, a) {
   return defaultDefineProperty(o, p, a);
 };
 
-  ${isInCloudfare
+  ${isInCloudflare
                 ? ""
                 : `
   const require = (await import("node:module")).createRequire(import.meta.url);
@@ -141,18 +141,7 @@ export async function generateEdgeBundle(name, options, fnOptions, additionalPlu
         throw new Error("Only one function is supported for now");
     }
     const middlewareInfo = functions[0];
-    //Copy wasm files
-    const wasmFiles = middlewareInfo.wasm;
-    mkdirSync(path.join(outputDir, "wasm"), { recursive: true });
-    for (const wasmFile of wasmFiles) {
-        fs.copyFileSync(path.join(buildOutputDotNextDir, wasmFile.filePath), path.join(outputDir, `wasm/${wasmFile.name}.wasm`));
-    }
-    // Copy assets
-    const assets = middlewareInfo.assets;
-    mkdirSync(path.join(outputDir, "assets"), { recursive: true });
-    for (const asset of assets) {
-        fs.copyFileSync(path.join(buildOutputDotNextDir, asset.filePath), path.join(outputDir, `assets/${asset.name}`));
-    }
+    copyMiddlewareResources(options, middlewareInfo, outputDir);
     await buildEdgeBundle({
         middlewareInfo,
         entrypoint: path.join(options.openNextDistDir, "adapters/edge-adapter.js"),
@@ -164,3 +153,16 @@ export async function generateEdgeBundle(name, options, fnOptions, additionalPlu
         additionalPlugins,
     });
 }
+/**
+ * Copy wasm files and assets into the destDir.
+ */
+export function copyMiddlewareResources(options, middlewareInfo, destDir) {
+    mkdirSync(path.join(destDir, "wasm"), { recursive: true });
+    for (const file of middlewareInfo?.wasm ?? []) {
+        fs.copyFileSync(path.join(options.appBuildOutputPath, ".next", file.filePath), path.join(destDir, `wasm/${file.name}.wasm`));
+    }
+    mkdirSync(path.join(destDir, "assets"), { recursive: true });
+    for (const file of middlewareInfo?.assets ?? []) {
+        fs.copyFileSync(path.join(options.appBuildOutputPath, ".next", file.filePath), path.join(destDir, `assets/${file.name}`));
+    }
+}

package/dist/build/helper.js

@@ -317,7 +317,7 @@ export async function isEdgeRuntime(overrides) {
         return false;
     }
     if (typeof overrides.wrapper === "string") {
-        return ["cloudflare-edge", "cloudflare"].includes(overrides.wrapper);
+        return ["cloudflare-edge", "cloudflare", "cloudflare-node"].includes(overrides.wrapper);
     }
     return (await overrides?.wrapper?.())?.edgeRuntime;
 }

package/dist/build.js

@@ -17,7 +17,7 @@ export async function build(openNextConfigPath, nodeExternals) {
     showWarningOnWindows();
     const baseDir = process.cwd();
     const openNextDistDir = url.fileURLToPath(new URL(".", import.meta.url));
-    const { config, buildDir } = await compileOpenNextConfig(baseDir, openNextConfigPath, nodeExternals);
+    const { config, buildDir } = await compileOpenNextConfig(baseDir, openNextConfigPath, { nodeExternals });
     // Initialize options
     const options = buildHelper.normalizeOptions(config, openNextDistDir, buildDir);
     logger.setLevel(options.debug ? "debug" : "info");

package/dist/core/requestHandler.js

@@ -2,7 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { IncomingMessage } from "../http/index.js";
 import { runWithOpenNextRequestContext } from "../utils/promise";
 import { NextConfig } from "../adapters/config/index";
-import { debug, error, warn } from "../adapters/logger";
+import { debug, error } from "../adapters/logger";
 import { patchAsyncStorage } from "./patchAsyncStorage";
 import { constructNextUrl, convertRes, convertToQuery, createServerResponse, } from "./routing/util";
 import routingHandler, { INTERNAL_HEADER_INITIAL_URL, INTERNAL_HEADER_RESOLVED_ROUTES, MIDDLEWARE_HEADER_PREFIX, MIDDLEWARE_HEADER_PREFIX_LEN, } from "./routingHandler";
@@ -39,12 +39,7 @@ export async function openNextHandler(internalEvent, options) {
             ...internalHeaders,
         };
         //#override withRouting
-        try {
-            routingResult = await routingHandler(internalEvent);
-        }
-        catch (e) {
-            warn("Routing failed.", e);
-        }
+        routingResult = await routingHandler(internalEvent);
         //#endOverride
         const headers = "type" in routingResult
             ? routingResult.headers

package/dist/core/routing/middleware.js

@@ -1,4 +1,4 @@
-import { FunctionsConfigManifest, MiddlewareManifest, NextConfig, } from "../../adapters/config/index.js";
+import { FunctionsConfigManifest, MiddlewareManifest, NextConfig, PrerenderManifest, } from "../../adapters/config/index.js";
 import { emptyReadableStream } from "../../utils/stream.js";
 import { localizePath } from "./i18n/index.js";
 //NOTE: we should try to avoid importing stuff from next as much as possible
@@ -24,7 +24,11 @@ function defaultMiddlewareLoader() {
 export async function handleMiddleware(internalEvent, middlewareLoader = defaultMiddlewareLoader) {
     const headers = internalEvent.headers;
     // We bypass the middleware if the request is internal
-    if (headers["x-isr"])
+    // We should only do that if the request has the correct `x-prerender-revalidate` header
+    // The `x-prerender-revalidate` header is set at build time and should be safe to trust
+    if (headers["x-isr"] &&
+        headers["x-prerender-revalidate"] ===
+            PrerenderManifest.preview.previewModeId)
         return internalEvent;
     // We only need the normalizedPath to check if the middleware should run
     const normalizedPath = localizePath(internalEvent);
@@ -113,13 +117,11 @@ export async function handleMiddleware(internalEvent, middlewareLoader = default
     // If the middleware returned a Rewrite, set the `url` to the pathname of the rewrite
     // NOTE: the header was added to `req` from above
     const rewriteUrl = responseHeaders.get("x-middleware-rewrite");
-    let rewritten = false;
     let isExternalRewrite = false;
     let middlewareQueryString = internalEvent.query;
     let newUrl = internalEvent.url;
     if (rewriteUrl) {
         newUrl = rewriteUrl;
-        rewritten = true;
         // If not a string, it should probably throw
         if (isExternal(newUrl, internalEvent.headers.host)) {
             isExternalRewrite = true;

package/dist/core/routing/util.js

@@ -202,7 +202,9 @@ export function fixCacheHeaderForHtmlPages(internalEvent, headers) {
     const localizedPath = localizePath(internalEvent);
     // WORKAROUND: `NextServer` does not set cache headers for HTML pages
     // https://opennext.js.org/aws/v2/advanced/workaround#workaround-nextserver-does-not-set-cache-headers-for-html-pages
-    if (HtmlPages.includes(localizedPath)) {
+    // Requests containing an `x-middleware-prefetch` header must not be cached
+    if (HtmlPages.includes(localizedPath) &&
+        !internalEvent.headers["x-middleware-prefetch"]) {
         headers[CommonHeaders.CACHE_CONTROL] =
             "public, max-age=0, s-maxage=31536000, must-revalidate";
     }

package/dist/core/routingHandler.js

@@ -1,5 +1,5 @@
 import { BuildId, ConfigHeaders, NextConfig, PrerenderManifest, RoutesManifest, } from "../adapters/config/index";
-import { debug } from "../adapters/logger";
+import { debug, error } from "../adapters/logger";
 import { cacheInterceptor } from "./routing/cacheInterceptor";
 import { detectLocale } from "./routing/i18n";
 import { fixDataPage, getNextConfigHeaders, handleFallbackFalse, handleRedirects, handleRewrites, } from "./routing/matcher";
@@ -32,121 +32,149 @@ function applyMiddlewareHeaders(eventHeaders, middlewareHeaders, setPrefix = tru
     });
 }
 export default async function routingHandler(event) {
-    // Add Next geo headers
-    for (const [openNextGeoName, nextGeoName] of Object.entries(geoHeaderToNextHeader)) {
-        const value = event.headers[openNextGeoName];
-        if (value) {
-            event.headers[nextGeoName] = value;
+    try {
+        // Add Next geo headers
+        for (const [openNextGeoName, nextGeoName] of Object.entries(geoHeaderToNextHeader)) {
+            const value = event.headers[openNextGeoName];
+            if (value) {
+                event.headers[nextGeoName] = value;
+            }
         }
-    }
-    // First we remove internal headers
-    // We don't want to allow users to set these headers
-    for (const key of Object.keys(event.headers)) {
-        if (key.startsWith(INTERNAL_HEADER_PREFIX) ||
-            key.startsWith(MIDDLEWARE_HEADER_PREFIX)) {
-            delete event.headers[key];
+        // First we remove internal headers
+        // We don't want to allow users to set these headers
+        for (const key of Object.keys(event.headers)) {
+            if (key.startsWith(INTERNAL_HEADER_PREFIX) ||
+                key.startsWith(MIDDLEWARE_HEADER_PREFIX)) {
+                delete event.headers[key];
+            }
         }
-    }
-    const nextHeaders = getNextConfigHeaders(event, ConfigHeaders);
-    let internalEvent = fixDataPage(event, BuildId);
-    if ("statusCode" in internalEvent) {
-        return internalEvent;
-    }
-    const redirect = handleRedirects(internalEvent, RoutesManifest.redirects);
-    if (redirect) {
-        debug("redirect", redirect);
-        return redirect;
-    }
-    const eventOrResult = await handleMiddleware(internalEvent);
-    const isResult = "statusCode" in eventOrResult;
-    if (isResult) {
-        return eventOrResult;
-    }
-    const middlewareResponseHeaders = eventOrResult.responseHeaders;
-    let isExternalRewrite = eventOrResult.isExternalRewrite ?? false;
-    // internalEvent is `InternalEvent | MiddlewareEvent`
-    internalEvent = eventOrResult;
-    if (!isExternalRewrite) {
-        // First rewrite to be applied
-        const beforeRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.beforeFiles);
-        internalEvent = beforeRewrites.internalEvent;
-        isExternalRewrite = beforeRewrites.isExternalRewrite;
-    }
-    const foundStaticRoute = staticRouteMatcher(internalEvent.rawPath);
-    const isStaticRoute = !isExternalRewrite && foundStaticRoute.length > 0;
-    if (!(isStaticRoute || isExternalRewrite)) {
-        // Second rewrite to be applied
-        const afterRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.afterFiles);
-        internalEvent = afterRewrites.internalEvent;
-        isExternalRewrite = afterRewrites.isExternalRewrite;
-    }
-    // We want to run this just before the dynamic route check
-    const { event: fallbackEvent, isISR } = handleFallbackFalse(internalEvent, PrerenderManifest);
-    internalEvent = fallbackEvent;
-    const foundDynamicRoute = dynamicRouteMatcher(internalEvent.rawPath);
-    const isDynamicRoute = !isExternalRewrite && foundDynamicRoute.length > 0;
-    if (!(isDynamicRoute || isStaticRoute || isExternalRewrite)) {
-        // Fallback rewrite to be applied
-        const fallbackRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.fallback);
-        internalEvent = fallbackRewrites.internalEvent;
-        isExternalRewrite = fallbackRewrites.isExternalRewrite;
-    }
-    // Api routes are not present in the routes manifest except if they're not behind /api
-    // /api even if it's a page route doesn't get generated in the manifest
-    // Ideally we would need to properly check api routes here
-    const isApiRoute = internalEvent.rawPath === apiPrefix ||
-        internalEvent.rawPath.startsWith(`${apiPrefix}/`);
-    const isNextImageRoute = internalEvent.rawPath.startsWith("/_next/image");
-    const isRouteFoundBeforeAllRewrites = isStaticRoute || isDynamicRoute || isExternalRewrite;
-    // If we still haven't found a route, we show the 404 page
-    // We need to ensure that rewrites are applied before showing the 404 page
-    if (!(isRouteFoundBeforeAllRewrites ||
-        isApiRoute ||
-        isNextImageRoute ||
-        // We need to check again once all rewrites have been applied
-        staticRouteMatcher(internalEvent.rawPath).length > 0 ||
-        dynamicRouteMatcher(internalEvent.rawPath).length > 0)) {
-        internalEvent = {
-            ...internalEvent,
-            rawPath: "/404",
-            url: constructNextUrl(internalEvent.url, "/404"),
-            headers: {
-                ...internalEvent.headers,
-                "x-middleware-response-cache-control": "private, no-cache, no-store, max-age=0, must-revalidate",
-            },
-        };
-    }
-    if (globalThis.openNextConfig.dangerous?.enableCacheInterception &&
-        !("statusCode" in internalEvent)) {
-        debug("Cache interception enabled");
-        internalEvent = await cacheInterceptor(internalEvent);
+        const nextHeaders = getNextConfigHeaders(event, ConfigHeaders);
+        let internalEvent = fixDataPage(event, BuildId);
         if ("statusCode" in internalEvent) {
-            applyMiddlewareHeaders(internalEvent.headers, {
-                ...middlewareResponseHeaders,
-                ...nextHeaders,
-            }, false);
             return internalEvent;
         }
+        const redirect = handleRedirects(internalEvent, RoutesManifest.redirects);
+        if (redirect) {
+            debug("redirect", redirect);
+            return redirect;
+        }
+        const eventOrResult = await handleMiddleware(internalEvent);
+        const isResult = "statusCode" in eventOrResult;
+        if (isResult) {
+            return eventOrResult;
+        }
+        const middlewareResponseHeaders = eventOrResult.responseHeaders;
+        let isExternalRewrite = eventOrResult.isExternalRewrite ?? false;
+        // internalEvent is `InternalEvent | MiddlewareEvent`
+        internalEvent = eventOrResult;
+        if (!isExternalRewrite) {
+            // First rewrite to be applied
+            const beforeRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.beforeFiles);
+            internalEvent = beforeRewrites.internalEvent;
+            isExternalRewrite = beforeRewrites.isExternalRewrite;
+        }
+        const foundStaticRoute = staticRouteMatcher(internalEvent.rawPath);
+        const isStaticRoute = !isExternalRewrite && foundStaticRoute.length > 0;
+        if (!(isStaticRoute || isExternalRewrite)) {
+            // Second rewrite to be applied
+            const afterRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.afterFiles);
+            internalEvent = afterRewrites.internalEvent;
+            isExternalRewrite = afterRewrites.isExternalRewrite;
+        }
+        // We want to run this just before the dynamic route check
+        const { event: fallbackEvent, isISR } = handleFallbackFalse(internalEvent, PrerenderManifest);
+        internalEvent = fallbackEvent;
+        const foundDynamicRoute = dynamicRouteMatcher(internalEvent.rawPath);
+        const isDynamicRoute = !isExternalRewrite && foundDynamicRoute.length > 0;
+        if (!(isDynamicRoute || isStaticRoute || isExternalRewrite)) {
+            // Fallback rewrite to be applied
+            const fallbackRewrites = handleRewrites(internalEvent, RoutesManifest.rewrites.fallback);
+            internalEvent = fallbackRewrites.internalEvent;
+            isExternalRewrite = fallbackRewrites.isExternalRewrite;
+        }
+        // Api routes are not present in the routes manifest except if they're not behind /api
+        // /api even if it's a page route doesn't get generated in the manifest
+        // Ideally we would need to properly check api routes here
+        const isApiRoute = internalEvent.rawPath === apiPrefix ||
+            internalEvent.rawPath.startsWith(`${apiPrefix}/`);
+        const isNextImageRoute = internalEvent.rawPath.startsWith("/_next/image");
+        const isRouteFoundBeforeAllRewrites = isStaticRoute || isDynamicRoute || isExternalRewrite;
+        // If we still haven't found a route, we show the 404 page
+        // We need to ensure that rewrites are applied before showing the 404 page
+        if (!(isRouteFoundBeforeAllRewrites ||
+            isApiRoute ||
+            isNextImageRoute ||
+            // We need to check again once all rewrites have been applied
+            staticRouteMatcher(internalEvent.rawPath).length > 0 ||
+            dynamicRouteMatcher(internalEvent.rawPath).length > 0)) {
+            internalEvent = {
+                ...internalEvent,
+                rawPath: "/404",
+                url: constructNextUrl(internalEvent.url, "/404"),
+                headers: {
+                    ...internalEvent.headers,
+                    "x-middleware-response-cache-control": "private, no-cache, no-store, max-age=0, must-revalidate",
+                },
+            };
+        }
+        if (globalThis.openNextConfig.dangerous?.enableCacheInterception &&
+            !("statusCode" in internalEvent)) {
+            debug("Cache interception enabled");
+            internalEvent = await cacheInterceptor(internalEvent);
+            if ("statusCode" in internalEvent) {
+                applyMiddlewareHeaders(internalEvent.headers, {
+                    ...middlewareResponseHeaders,
+                    ...nextHeaders,
+                }, false);
+                return internalEvent;
+            }
+        }
+        // We apply the headers from the middleware response last
+        applyMiddlewareHeaders(internalEvent.headers, {
+            ...middlewareResponseHeaders,
+            ...nextHeaders,
+        });
+        const resolvedRoutes = [
+            ...foundStaticRoute,
+            ...foundDynamicRoute,
+        ];
+        debug("resolvedRoutes", resolvedRoutes);
+        return {
+            internalEvent,
+            isExternalRewrite,
+            origin: false,
+            isISR,
+            resolvedRoutes,
+            initialURL: event.url,
+            locale: NextConfig.i18n
+                ? detectLocale(internalEvent, NextConfig.i18n)
+                : undefined,
+        };
+    }
+    catch (e) {
+        error("Error in routingHandler", e);
+        // In case of an error, we want to return the 500 page from Next.js
+        return {
+            internalEvent: {
+                type: "core",
+                method: "GET",
+                rawPath: "/500",
+                url: constructNextUrl(event.url, "/500"),
+                headers: {
+                    ...event.headers,
+                },
+                query: event.query,
+                cookies: event.cookies,
+                remoteAddress: event.remoteAddress,
+            },
+            isExternalRewrite: false,
+            origin: false,
+            isISR: false,
+            resolvedRoutes: [],
+            initialURL: event.url,
+            locale: NextConfig.i18n
+                ? detectLocale(event, NextConfig.i18n)
+                : undefined,
+        };
     }
-    // We apply the headers from the middleware response last
-    applyMiddlewareHeaders(internalEvent.headers, {
-        ...middlewareResponseHeaders,
-        ...nextHeaders,
-    });
-    const resolvedRoutes = [
-        ...foundStaticRoute,
-        ...foundDynamicRoute,
-    ];
-    debug("resolvedRoutes", resolvedRoutes);
-    return {
-        internalEvent,
-        isExternalRewrite,
-        origin: false,
-        isISR,
-        resolvedRoutes,
-        initialURL: event.url,
-        locale: NextConfig.i18n
-            ? detectLocale(internalEvent, NextConfig.i18n)
-            : undefined,
-    };
 }

package/dist/overrides/wrappers/node.js

@@ -8,7 +8,6 @@ const wrapper = async (handler, converter) => {
                 res.setHeader("Set-Cookie", prelude.cookies);
                 res.writeHead(prelude.statusCode, prelude.headers);
                 res.flushHeaders();
-                res.uncork();
                 return res;
             },
         };

package/dist/plugins/edge.d.ts

@@ -3,12 +3,12 @@ import type { MiddlewareInfo } from "../types/next-types.js";
 export interface IPluginSettings {
     nextDir: string;
     middlewareInfo?: MiddlewareInfo;
-    isInCloudfare?: boolean;
+    isInCloudflare?: boolean;
 }
 /**
  * @param opts.nextDir - The path to the .next directory
  * @param opts.middlewareInfo - Information about the middleware
- * @param opts.isInCloudfare - Whether the code runs on the cloudflare runtime
+ * @param opts.isInCloudflare - Whether the code runs on the cloudflare runtime
  * @returns
  */
-export declare function openNextEdgePlugins({ nextDir, middlewareInfo, isInCloudfare, }: IPluginSettings): Plugin;
+export declare function openNextEdgePlugins({ nextDir, middlewareInfo, isInCloudflare, }: IPluginSettings): Plugin;

package/dist/plugins/edge.js

@@ -7,10 +7,10 @@ import { getCrossPlatformPathRegex } from "../utils/regex.js";
 /**
  * @param opts.nextDir - The path to the .next directory
  * @param opts.middlewareInfo - Information about the middleware
- * @param opts.isInCloudfare - Whether the code runs on the cloudflare runtime
+ * @param opts.isInCloudflare - Whether the code runs on the cloudflare runtime
  * @returns
  */
-export function openNextEdgePlugins({ nextDir, middlewareInfo, isInCloudfare, }) {
+export function openNextEdgePlugins({ nextDir, middlewareInfo, isInCloudflare, }) {
     const entryFiles = middlewareInfo?.files.map((file) => path.join(nextDir, file)) ?? [];
     const routes = middlewareInfo
         ? [
@@ -54,7 +54,7 @@ globalThis._ENTRIES = {};
 globalThis.self = globalThis;
 globalThis._ROUTES = ${JSON.stringify(routes)};
 
-${isInCloudfare
+${isInCloudflare
                     ? ""
                     : `
 import {readFileSync} from "node:fs";
@@ -97,11 +97,7 @@ if (!globalThis.URLPattern) {
   await import("urlpattern-polyfill");
 }
 `}
-${wasmFiles
-                    .map((file) => isInCloudfare
-                    ? `import ${file.name} from './wasm/${file.name}.wasm';`
-                    : `const ${file.name} = readFileSync(path.join(__dirname,'/wasm/${file.name}.wasm'));`)
-                    .join("\n")}
+${importWasm(wasmFiles, { isInCloudflare })}
 ${entryFiles.map((file) => `require("${file}");`).join("\n")}
 ${contents}
         `;
@@ -153,3 +149,17 @@ ${contents}
         },
     };
 }
+function importWasm(files, { isInCloudflare }) {
+    return files
+        .map(({ name }) => {
+        if (isInCloudflare) {
+            // As `.next/server/src/middleware.js` references the name,
+            // using `import ${name} from '...'` would cause ESBuild to rename the import.
+            // We use `globalThis.${name}` to make sure `middleware.js` reference name will match.
+            return `import __onw_${name}__ from './wasm/${name}.wasm'
+globalThis.${name} = __onw_${name}__`;
+        }
+        return `const ${name} = readFileSync(path.join(__dirname,'/wasm/${name}.wasm'));`;
+    })
+        .join("\n");
+}

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

@@ -152,6 +152,9 @@ export interface PrerenderManifest {
             dataRouteRegex: string;
         };
     };
+    preview: {
+        previewModeId: string;
+    };
 }
 export type Options = {
     internalEvent: InternalEvent;

package/package.json

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