@opennextjs/aws 3.2.1 → 3.2.2

package/dist/build/createAssets.js

@@ -4,17 +4,22 @@ import { isBinaryContentType } from "../adapters/binary.js";
 import logger from "../logger.js";
 import * as buildHelper from "./helper.js";
 export function createStaticAssets(options) {
-    logger.info(`Bundling static assets...`);
+    logger.info("Bundling static assets...");
     const { appBuildOutputPath, appPublicPath, outputDir, appPath } = options;
     // Create output folder
     const outputPath = path.join(outputDir, "assets");
     fs.mkdirSync(outputPath, { recursive: true });
-    // Next.js outputs assets into multiple files. Copy into the same directory.
-    // Copy over:
-    // - .next/BUILD_ID => _next/BUILD_ID
-    // - .next/static   => _next/static
-    // - public/*       => *
-    // - app/favicon.ico or src/app/favicon.ico  => favicon.ico
+    /**
+     * Next.js outputs assets into multiple files. Copy into the same directory.
+     *
+     * Copy over:
+     * - .next/BUILD_ID => BUILD_ID
+     * - .next/static   => _next/static
+     * - public/*       => *
+     * - app/favicon.ico or src/app/favicon.ico  => favicon.ico
+     *
+     * Note: BUILD_ID is used by the SST infra.
+     */
     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)) {
@@ -24,7 +29,9 @@ export function createStaticAssets(options) {
         ? "src/app"
         : "app";
     const faviconPath = path.join(appPath, appSrcPath, "favicon.ico");
-    if (fs.existsSync(faviconPath)) {
+    // We need to check if the favicon is either a file or directory.
+    // If it's a directory, we assume it's a route handler and ignore it.
+    if (fs.existsSync(faviconPath) && fs.lstatSync(faviconPath).isFile()) {
         fs.copyFileSync(faviconPath, path.join(outputPath, "favicon.ico"));
     }
 }
@@ -35,7 +42,7 @@ export function createStaticAssets(options) {
  * @returns Whether tag cache is used.
  */
 export function createCacheAssets(options) {
-    logger.info(`Bundling cache assets...`);
+    logger.info("Bundling cache assets...");
     const { appBuildOutputPath, outputDir } = options;
     const packagePath = path.relative(options.monorepoRoot, appBuildOutputPath);
     const buildId = buildHelper.getBuildId(appBuildOutputPath);
@@ -49,27 +56,29 @@ export function createCacheAssets(options) {
         .forEach((dir) => fs.cpSync(dir, outputPath, { recursive: true }));
     // Remove non-cache files
     const htmlPages = buildHelper.getHtmlPages(dotNextPath);
-    buildHelper.removeFiles(outputPath, (file) => file.endsWith(".js") ||
-        file.endsWith(".js.nft.json") ||
-        (file.endsWith(".html") && htmlPages.has(file)));
+    buildHelper.removeFiles(outputPath, ({ relativePath }) => relativePath.endsWith(".js") ||
+        relativePath.endsWith(".js.nft.json") ||
+        (relativePath.endsWith(".html") && htmlPages.has(relativePath)));
     // Merge cache files into a single file
     const cacheFilesPath = {};
-    buildHelper.traverseFiles(outputPath, () => true, (filepath) => {
-        const ext = path.extname(filepath);
+    buildHelper.traverseFiles(outputPath, () => true, ({ absolutePath }) => {
+        const ext = path.extname(absolutePath);
         switch (ext) {
             case ".meta":
             case ".html":
             case ".json":
             case ".body":
-            case ".rsc":
-                const newFilePath = filepath
-                    .substring(0, filepath.length - ext.length)
-                    .replace(/\.prefetch$/, "") + ".cache";
+            case ".rsc": {
+                const newFilePath = absolutePath
+                    .substring(0, absolutePath.length - ext.length)
+                    .replace(/\.prefetch$/, "")
+                    .concat(".cache");
                 cacheFilesPath[newFilePath] = {
-                    [ext.slice(1)]: filepath,
+                    [ext.slice(1)]: absolutePath,
                     ...cacheFilesPath[newFilePath],
                 };
                 break;
+            }
             case ".map":
                 break;
             default:
@@ -106,8 +115,8 @@ export function createCacheAssets(options) {
         const metaFiles = [];
         // Compute dynamodb cache data
         // Traverse files inside cache to find all meta files and cache tags associated with them
-        buildHelper.traverseFiles(outputPath, (file) => file.endsWith(".meta"), (filePath) => {
-            const fileContent = fs.readFileSync(filePath, "utf8");
+        buildHelper.traverseFiles(outputPath, ({ absolutePath }) => absolutePath.endsWith(".meta"), ({ absolutePath, relativePath }) => {
+            const fileContent = fs.readFileSync(absolutePath, "utf8");
             const fileData = JSON.parse(fileContent);
             if (fileData.headers?.["x-next-cache-tags"]) {
                 fileData.headers["x-next-cache-tags"]
@@ -117,7 +126,7 @@ export function createCacheAssets(options) {
                     metaFiles.push({
                         tag: { S: path.posix.join(buildId, tag.trim()) },
                         path: {
-                            S: path.posix.join(buildId, path.relative(outputPath, filePath).replace(".meta", "")),
+                            S: path.posix.join(buildId, relativePath.replace(".meta", "")),
                         },
                         // We don't care about the revalidation time here, we just need to make sure it's there
                         revalidatedAt: { N: "1" },
@@ -131,14 +140,14 @@ export function createCacheAssets(options) {
             const fetchOutputPath = path.join(outputDir, "cache", "__fetch", buildId);
             fs.mkdirSync(fetchOutputPath, { recursive: true });
             fs.cpSync(fetchCachePath, fetchOutputPath, { recursive: true });
-            buildHelper.traverseFiles(fetchCachePath, () => true, (filepath) => {
-                const fileContent = fs.readFileSync(filepath, "utf8");
+            buildHelper.traverseFiles(fetchCachePath, () => true, ({ absolutePath, relativePath }) => {
+                const fileContent = fs.readFileSync(absolutePath, "utf8");
                 const fileData = JSON.parse(fileContent);
                 fileData?.tags?.forEach((tag) => {
                     metaFiles.push({
                         tag: { S: path.posix.join(buildId, tag) },
                         path: {
-                            S: path.posix.join(buildId, path.relative(fetchCachePath, filepath)),
+                            S: path.posix.join(buildId, relativePath),
                         },
                         revalidatedAt: { N: "1" },
                     });
@@ -156,6 +165,6 @@ export function createCacheAssets(options) {
         }
     }
     // We need to remove files later because we need the metafiles for dynamodb tags cache
-    buildHelper.removeFiles(outputPath, (file) => !file.endsWith(".cache"));
+    buildHelper.removeFiles(outputPath, ({ relativePath }) => !relativePath.endsWith(".cache"));
     return { useTagCache };
 }

package/dist/build/createImageOptimizationBundle.js

@@ -8,7 +8,7 @@ import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
 const require = createRequire(import.meta.url);
 export async function createImageOptimizationBundle(options) {
-    logger.info(`Bundling image optimization function...`);
+    logger.info("Bundling image optimization function...");
     const { appBuildOutputPath, config, outputDir } = options;
     // Create output folder
     const outputPath = path.join(outputDir, "image-optimization-function");

package/dist/build/createMiddleware.js

@@ -11,7 +11,7 @@ import { installDependencies } from "./installDeps.js";
  * @param forceOnlyBuildOnce force to build only once.
  */
 export async function createMiddleware(options, { forceOnlyBuildOnce = false } = {}) {
-    logger.info(`Bundling middleware function...`);
+    logger.info("Bundling middleware function...");
     const { appBuildOutputPath, config, outputDir } = options;
     // Get middleware manifest
     const middlewareManifest = JSON.parse(fs.readFileSync(path.join(appBuildOutputPath, ".next/server/middleware-manifest.json"), "utf8"));
@@ -27,11 +27,15 @@ export async function createMiddleware(options, { forceOnlyBuildOnce = false } =
             outfile: path.join(outputPath, "handler.mjs"),
             middlewareInfo,
             options,
-            overrides: config.middleware?.override,
+            overrides: {
+                ...config.middleware.override,
+                originResolver: config.middleware.originResolver,
+            },
             defaultConverter: "aws-cloudfront",
             includeCache: config.dangerous?.enableCacheInterception,
             additionalExternals: config.edgeExternals,
             onlyBuildOnce: forceOnlyBuildOnce === true,
+            name: "middleware",
         });
         installDependencies(outputPath, config.middleware?.install);
     }
@@ -42,6 +46,7 @@ export async function createMiddleware(options, { forceOnlyBuildOnce = false } =
             middlewareInfo,
             options,
             onlyBuildOnce: true,
+            name: "middleware",
         });
     }
 }

package/dist/build/createRevalidationBundle.js

@@ -5,7 +5,7 @@ import { openNextResolvePlugin } from "../plugins/resolve.js";
 import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
 export async function createRevalidationBundle(options) {
-    logger.info(`Bundling revalidation function...`);
+    logger.info("Bundling revalidation function...");
     const { appBuildOutputPath, config, outputDir } = options;
     // Create output folder
     const outputPath = path.join(outputDir, "revalidation-function");

package/dist/build/createServerBundle.js

@@ -42,28 +42,22 @@ export async function createServerBundle(options) {
     // Find app dir routes
     if (fs.existsSync(path.join(serverPath, "app"))) {
         const appPath = path.join(serverPath, "app");
-        buildHelper.traverseFiles(appPath, (file) => {
-            if (file.endsWith("page.js") || file.endsWith("route.js")) {
-                const route = `app/${file.replace(/\.js$/, "")}`;
-                if (!foundRoutes.has(route)) {
-                    remainingRoutes.add(route);
-                }
+        buildHelper.traverseFiles(appPath, ({ relativePath }) => relativePath.endsWith("page.js") || relativePath.endsWith("route.js"), ({ relativePath }) => {
+            const route = `app/${relativePath.replace(/\.js$/, "")}`;
+            if (!foundRoutes.has(route)) {
+                remainingRoutes.add(route);
             }
-            return false;
-        }, () => { });
+        });
     }
     // Find pages dir routes
     if (fs.existsSync(path.join(serverPath, "pages"))) {
         const pagePath = path.join(serverPath, "pages");
-        buildHelper.traverseFiles(pagePath, (file) => {
-            if (file.endsWith(".js")) {
-                const route = `pages/${file.replace(/\.js$/, "")}`;
-                if (!foundRoutes.has(route)) {
-                    remainingRoutes.add(route);
-                }
+        buildHelper.traverseFiles(pagePath, ({ relativePath }) => relativePath.endsWith(".js"), ({ relativePath }) => {
+            const route = `pages/${relativePath.replace(/\.js$/, "")}`;
+            if (!foundRoutes.has(route)) {
+                remainingRoutes.add(route);
             }
-            return false;
-        }, () => { });
+        });
     }
     // Generate default function
     await generateBundle("default", options, {
@@ -94,7 +88,9 @@ async function generateBundle(name, options, fnOptions) {
     // Bundle next server if necessary
     const isBundled = fnOptions.experimentalBundledNextServer ?? false;
     if (isBundled) {
-        await bundleNextServer(path.join(outputPath, packagePath), appPath);
+        await bundleNextServer(path.join(outputPath, packagePath), appPath, {
+            debug: options.debug,
+        });
     }
     // Copy middleware
     if (!config.middleware?.external) {
@@ -132,20 +128,16 @@ async function generateBundle(name, options, fnOptions) {
                 ...(disableNextPrebundledReact ? ["requireHooks"] : []),
                 ...(disableRouting ? ["trustHostHeader"] : []),
                 ...(!isBefore13413 ? ["requestHandlerHost"] : []),
-                ...(!isAfter141 ? ["stableIncrementalCache"] : []),
-                ...(isAfter141 ? ["experimentalIncrementalCacheHandler"] : []),
+                ...(isAfter141
+                    ? ["experimentalIncrementalCacheHandler"]
+                    : ["stableIncrementalCache"]),
             ],
         }),
         openNextResolvePlugin({
             fnName: name,
-            overrides: overrides,
+            overrides,
         }),
     ];
-    if (plugins && plugins.length > 0) {
-        logger.debug(`Applying plugins:: [${plugins
-            .map(({ name }) => name)
-            .join(",")}] for Next version: ${options.nextVersion}`);
-    }
     const outfileExt = fnOptions.runtime === "deno" ? "ts" : "mjs";
     await buildHelper.esbuildAsync({
         entryPoints: [
@@ -167,9 +159,11 @@ async function generateBundle(name, options, fnOptions) {
         },
         plugins,
         alias: {
-            "next/dist/server/next-server.js": isBundled
-                ? "./next-server.runtime.prod.js"
-                : "next/dist/server/next-server.js",
+            ...(isBundled
+                ? {
+                    "next/dist/server/next-server.js": "./next-server.runtime.prod.js",
+                }
+                : {}),
         },
     }, options);
     if (isMonorepo) {
@@ -217,7 +211,7 @@ function addMonorepoEntrypoint(outputPath, packagePath) {
     fs.writeFileSync(path.join(outputPath, "index.mjs"), [`export * from "./${packagePosixPath}/index.mjs";`].join(""));
 }
 async function minifyServerBundle(outputDir) {
-    logger.info(`Minimizing server function...`);
+    logger.info("Minimizing server function...");
     await minifyAll(outputDir, {
         compress_json: true,
         mangle: true,

package/dist/build/createWarmerBundle.js

@@ -5,7 +5,7 @@ import { openNextResolvePlugin } from "../plugins/resolve.js";
 import * as buildHelper from "./helper.js";
 import { installDependencies } from "./installDeps.js";
 export async function createWarmerBundle(options) {
-    logger.info(`Bundling warmer function...`);
+    logger.info("Bundling warmer function...");
     const { config, outputDir } = options;
     // Create output folder
     const outputPath = path.join(outputDir, "warmer-function");

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

@@ -1,18 +1,22 @@
 import type { MiddlewareInfo } from "../../types/next-types";
-import type { IncludedConverter, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
+import type { IncludedConverter, IncludedOriginResolver, LazyLoadedOverride, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
+import type { OriginResolver } from "../../types/overrides.js";
 import type { BuildOptions } from "../helper.js";
 interface BuildEdgeBundleOptions {
     middlewareInfo?: MiddlewareInfo;
     entrypoint: string;
     outfile: string;
     options: BuildOptions;
-    overrides?: OverrideOptions;
+    overrides?: OverrideOptions & {
+        originResolver?: LazyLoadedOverride<OriginResolver> | IncludedOriginResolver;
+    };
     defaultConverter?: IncludedConverter;
     additionalInject?: string;
     includeCache?: boolean;
     additionalExternals?: string[];
     onlyBuildOnce?: boolean;
+    name: string;
 }
-export declare function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }: BuildEdgeBundleOptions): Promise<void>;
+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 {};

package/dist/build/edge/createEdgeBundle.js

@@ -1,19 +1,18 @@
 import { mkdirSync } from "node:fs";
+import fs from "node:fs";
+import path from "node:path";
 import { build } from "esbuild";
-import fs from "fs";
-import path from "path";
 import logger from "../../logger.js";
 import { openNextEdgePlugins } from "../../plugins/edge.js";
 import { openNextReplacementPlugin } from "../../plugins/replacement.js";
 import { openNextResolvePlugin } from "../../plugins/resolve.js";
 import { copyOpenNextConfig, esbuildAsync } from "../helper.js";
-export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }) {
+export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, name, }) {
     const isInCloudfare = typeof overrides?.wrapper === "string"
         ? overrides.wrapper === "cloudflare"
         : (await overrides?.wrapper?.())?.edgeRuntime;
     await esbuildAsync({
         entryPoints: [entrypoint],
-        // inject: ,
         bundle: true,
         outfile,
         external: ["node:*", "next", "@aws-sdk/*"],
@@ -41,7 +40,14 @@ export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, opt
                                 : "sqs-lite",
                         }
                         : {}),
+                    originResolver: typeof overrides?.originResolver === "string"
+                        ? overrides.originResolver
+                        : "pattern-env",
+                    proxyExternalRequest: typeof overrides?.proxyExternalRequest === "string"
+                        ? overrides.proxyExternalRequest
+                        : "node",
                 },
+                fnName: name,
             }),
             openNextReplacementPlugin({
                 name: "externalMiddlewareOverrides",
@@ -95,7 +101,7 @@ globalThis.AsyncLocalStorage = AsyncLocalStorage;
             outfile,
             allowOverwrite: true,
             bundle: true,
-            minify: true,
+            minify: !options.debug,
             platform: "node",
             format: "esm",
             conditions: ["workerd", "worker", "browser"],
@@ -141,5 +147,6 @@ export async function generateEdgeBundle(name, options, fnOptions) {
         options,
         overrides: fnOptions.override,
         additionalExternals: options.config.edgeExternals,
+        name,
     });
 }

package/dist/build/generateOutput.js

@@ -6,15 +6,11 @@ async function canStream(opts) {
     if (!opts.override?.wrapper) {
         return false;
     }
-    else {
-        if (typeof opts.override.wrapper === "string") {
-            return opts.override.wrapper === "aws-lambda-streaming";
-        }
-        else {
-            const wrapper = await opts.override.wrapper();
-            return wrapper.supportStreaming;
-        }
+    if (typeof opts.override.wrapper === "string") {
+        return opts.override.wrapper === "aws-lambda-streaming";
     }
+    const wrapper = await opts.override.wrapper();
+    return wrapper.supportStreaming;
 }
 async function extractOverrideName(defaultName, override) {
     if (!override) {
@@ -23,10 +19,8 @@ async function extractOverrideName(defaultName, override) {
     if (typeof override === "string") {
         return override;
     }
-    else {
-        const overrideModule = await override();
-        return overrideModule.name;
-    }
+    const overrideModule = await override();
+    return overrideModule.name;
 }
 async function extractOverrideFn(override) {
     if (!override) {
@@ -190,7 +184,7 @@ export async function generateOutput(options) {
         edgeFunction: isExternalMiddleware ? "middleware" : undefined,
     });
     behaviors.push({
-        pattern: "*",
+        pattern: "*", // This is the default behavior
         origin: "default",
         edgeFunction: isExternalMiddleware ? "middleware" : undefined,
     });

package/dist/build/helper.d.ts

@@ -19,15 +19,33 @@ export declare function normalizeOptions(config: OpenNextConfig, distDir: string
 };
 export declare function esbuildSync(esbuildOptions: ESBuildOptions, options: BuildOptions): void;
 export declare function esbuildAsync(esbuildOptions: ESBuildOptions, options: BuildOptions): Promise<void>;
-export declare function removeFiles(root: string, conditionFn: (file: string) => boolean, searchingDir?: string): void;
+/**
+ *  Type of the parameter of `traverseFiles` callbacks
+ */
+export type TraversePath = {
+    absolutePath: string;
+    relativePath: string;
+};
 /**
  * Recursively traverse files in a directory and call `callbackFn` when `conditionFn` returns true
+ *
+ * The callbacks are passed both the absolute and relative (to root) path to files.
+ *
  * @param root - Root directory to search
- * @param conditionFn - Called to determine if `callbackFn` should be called
- * @param callbackFn - Called when `conditionFn` returns true
+ * @param conditionFn - Called to determine if `callbackFn` should be called.
+ * @param callbackFn - Called when `conditionFn` returns true.
  * @param searchingDir - Directory to search (used for recursion)
  */
-export declare function traverseFiles(root: string, conditionFn: (file: string) => boolean, callbackFn: (filePath: string) => void, searchingDir?: string): void;
+export declare function traverseFiles(root: string, conditionFn: (paths: TraversePath) => boolean, callbackFn: (paths: TraversePath) => void, searchingDir?: string): void;
+/**
+ * Recursively delete files.
+ *
+ * @see `traverseFiles`.
+ *
+ * @param root Root directory to search.
+ * @param conditionFn Predicate used to delete the files.
+ */
+export declare function removeFiles(root: string, conditionFn: (paths: TraversePath) => boolean): void;
 export declare function getHtmlPages(dotNextPath: string): Set<string>;
 export declare function getBuildId(dotNextPath: string): string;
 export declare function getOpenNextVersion(): string;

package/dist/build/helper.js

@@ -74,7 +74,7 @@ export function esbuildSync(esbuildOptions, options) {
         format: "esm",
         platform: "node",
         bundle: true,
-        minify: debug ? false : true,
+        minify: !debug,
         mainFields: ["module", "main"],
         sourcemap: debug ? "inline" : false,
         sourcesContent: false,
@@ -101,7 +101,7 @@ export async function esbuildAsync(esbuildOptions, options) {
         format: "esm",
         platform: "node",
         bundle: true,
-        minify: debug ? false : true,
+        minify: !debug,
         mainFields: ["module", "main"],
         sourcemap: debug ? "inline" : false,
         sourcesContent: false,
@@ -125,28 +125,40 @@ export async function esbuildAsync(esbuildOptions, options) {
         throw new Error(`There was a problem bundling ${esbuildOptions.entryPoints[0]}.`);
     }
 }
-export function removeFiles(root, conditionFn, searchingDir = "") {
-    traverseFiles(root, conditionFn, (filePath) => fs.rmSync(filePath, { force: true }), searchingDir);
-}
 /**
  * Recursively traverse files in a directory and call `callbackFn` when `conditionFn` returns true
+ *
+ * The callbacks are passed both the absolute and relative (to root) path to files.
+ *
  * @param root - Root directory to search
- * @param conditionFn - Called to determine if `callbackFn` should be called
- * @param callbackFn - Called when `conditionFn` returns true
+ * @param conditionFn - Called to determine if `callbackFn` should be called.
+ * @param callbackFn - Called when `conditionFn` returns true.
  * @param searchingDir - Directory to search (used for recursion)
  */
 export function traverseFiles(root, conditionFn, callbackFn, searchingDir = "") {
     fs.readdirSync(path.join(root, searchingDir)).forEach((file) => {
-        const filePath = path.join(root, searchingDir, file);
-        if (fs.statSync(filePath).isDirectory()) {
-            traverseFiles(root, conditionFn, callbackFn, path.join(searchingDir, file));
+        const relativePath = path.join(searchingDir, file);
+        const absolutePath = path.join(root, relativePath);
+        if (fs.statSync(absolutePath).isDirectory()) {
+            traverseFiles(root, conditionFn, callbackFn, relativePath);
             return;
         }
-        if (conditionFn(path.join(searchingDir, file))) {
-            callbackFn(filePath);
+        if (conditionFn({ absolutePath, relativePath })) {
+            callbackFn({ absolutePath, relativePath });
         }
     });
 }
+/**
+ * Recursively delete files.
+ *
+ * @see `traverseFiles`.
+ *
+ * @param root Root directory to search.
+ * @param conditionFn Predicate used to delete the files.
+ */
+export function removeFiles(root, conditionFn) {
+    traverseFiles(root, conditionFn, ({ absolutePath }) => fs.rmSync(absolutePath, { force: true }));
+}
 export function getHtmlPages(dotNextPath) {
     // Get a list of HTML pages
     //
@@ -187,9 +199,11 @@ export function compareSemver(v1, v2) {
     if (v1 === "latest")
         return 1;
     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, patch1] = v1.split(".").map(Number);

package/dist/build/installDeps.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { execSync } from "child_process";
+import { execSync } from "node:child_process";
 import logger from "../logger.js";
 export function installDependencies(outputDir, installOptions) {
     try {

package/dist/build/patch/patchedAsyncStorage.js

@@ -8,7 +8,7 @@ const staticGenerationAsyncStorage = {
         if (store) {
             store.isOnDemandRevalidate =
                 store.isOnDemandRevalidate &&
-                    !globalThis.__als.getStore().isISRRevalidation;
+                    !globalThis.__openNextAls.getStore().isISRRevalidation;
         }
         return store;
     },

package/dist/build/utils.js

@@ -1,12 +1,13 @@
 import os from "node:os";
 import logger from "../logger.js";
 export function printHeader(header) {
+    // biome-ignore lint/style/noParameterAssign:
     header = `OpenNext — ${header}`;
     logger.info([
         "",
-        "┌" + "─".repeat(header.length + 2) + "┐",
+        `┌${"─".repeat(header.length + 2)}┐`,
         `│ ${header} │`,
-        "└" + "─".repeat(header.length + 2) + "┘",
+        `└${"─".repeat(header.length + 2)}┘`,
         "",
     ].join("\n"));
 }

package/dist/build/validateConfig.js

@@ -9,6 +9,7 @@ const compatibilityMatrix = {
     "aws-lambda-streaming": ["aws-apigw-v2"],
     cloudflare: ["edge"],
     node: ["node"],
+    dummy: [],
 };
 function validateFunctionOptions(fnOptions) {
     if (fnOptions.runtime === "edge" && fnOptions.experimentalBundledNextServer) {

package/dist/core/createGenericHandler.d.ts

@@ -1,7 +1,5 @@
-import type { BaseEventOrResult, InternalEvent, InternalResult, OpenNextConfig, OpenNextHandler } from "../types/open-next";
-declare global {
-    var openNextConfig: Partial<OpenNextConfig>;
-}
+import type { BaseEventOrResult, InternalEvent, InternalResult } from "../types/open-next";
+import type { OpenNextHandler } from "../types/overrides";
 type HandlerType = "imageOptimization" | "revalidate" | "warmer" | "middleware" | "initializationFunction";
 type GenericHandler<Type extends HandlerType, E extends BaseEventOrResult = InternalEvent, R extends BaseEventOrResult = InternalResult> = {
     handler: OpenNextHandler<E, R>;

package/dist/core/createGenericHandler.js

@@ -1,8 +1,7 @@
 import { debug } from "../adapters/logger";
 import { resolveConverter, resolveWrapper } from "./resolve";
 export async function createGenericHandler(handler) {
-    //First we load the config
-    // @ts-expect-error
+    // @ts-expect-error `./open-next.config.mjs` exists only in the build output
     const config = await import("./open-next.config.mjs").then((m) => m.default);
     globalThis.openNextConfig = config;
     const override = config[handler.type]

package/dist/core/createMainHandler.d.ts

@@ -1,18 +1 @@
-/// <reference types="node" />
-import type { AsyncLocalStorage } from "node:async_hooks";
-import type { DetachedPromiseRunner } from "../utils/promise";
-import type { IncrementalCache } from "../overrides/incrementalCache/types";
-import type { Queue } from "../overrides/queue/types";
-declare global {
-    var queue: Queue;
-    var incrementalCache: IncrementalCache;
-    var fnName: string | undefined;
-    var serverId: string;
-    var __als: AsyncLocalStorage<{
-        requestId: string;
-        pendingPromiseRunner: DetachedPromiseRunner;
-        isISRRevalidation?: boolean;
-        mergeHeadersPriority?: "middleware" | "handler";
-    }>;
-}
 export declare function createMainHandler(): Promise<(...args: any[]) => any>;