@opennextjs/aws 3.1.4

package/dist/adapters/revalidate.d.ts

@@ -0,0 +1,9 @@
+export interface RevalidateEvent {
+    type: "revalidate";
+    records: {
+        host: string;
+        url: string;
+        id: string;
+    }[];
+}
+export declare const handler: (...args: any[]) => any;

package/dist/adapters/revalidate.js

@@ -0,0 +1,71 @@
+import fs from "node:fs";
+import https from "node:https";
+import path from "node:path";
+import { createGenericHandler } from "../core/createGenericHandler.js";
+import { debug, error } from "./logger.js";
+const prerenderManifest = loadPrerenderManifest();
+const defaultHandler = async (event) => {
+    const failedRecords = [];
+    for (const record of event.records) {
+        const { host, url } = record;
+        debug(`Revalidating stale page`, { host, url });
+        // Make a HEAD request to the page to revalidate it. This will trigger
+        // the page to be re-rendered and cached in S3
+        // - HEAD request is used b/c it's not necessary to make a GET request
+        //   and have CloudFront cache the request. This is because the request
+        //   does not have real life headers and the cache won't be used anyway.
+        // - "previewModeId" is used to ensure the page is revalidated in a
+        //   blocking way in lambda
+        //   https://github.com/vercel/next.js/blob/1088b3f682cbe411be2d1edc502f8a090e36dee4/packages/next/src/server/api-utils/node.ts#L353
+        try {
+            await new Promise((resolve, reject) => {
+                const req = https.request(`https://${host}${url}`, {
+                    method: "HEAD",
+                    headers: {
+                        "x-prerender-revalidate": prerenderManifest.preview.previewModeId,
+                        "x-isr": "1",
+                    },
+                }, (res) => {
+                    debug("revalidating", {
+                        url,
+                        host,
+                        headers: res.headers,
+                        statusCode: res.statusCode,
+                    });
+                    if (res.statusCode !== 200 ||
+                        res.headers["x-nextjs-cache"] !== "REVALIDATED") {
+                        failedRecords.push(record);
+                    }
+                    resolve(res);
+                });
+                req.on("error", (err) => {
+                    error(`Error revalidating page`, { host, url });
+                    reject(err);
+                });
+                req.end();
+            });
+        }
+        catch (err) {
+            failedRecords.push(record);
+        }
+    }
+    if (failedRecords.length > 0) {
+        error(`Failed to revalidate ${failedRecords.length} pages`, {
+            failedRecords,
+        });
+    }
+    return {
+        type: "revalidate",
+        // Records returned here are the ones that failed to revalidate
+        records: failedRecords,
+    };
+};
+export const handler = await createGenericHandler({
+    handler: defaultHandler,
+    type: "revalidate",
+});
+function loadPrerenderManifest() {
+    const filePath = path.join("prerender-manifest.json");
+    const json = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(json);
+}

package/dist/adapters/server-adapter.d.ts

@@ -0,0 +1,4 @@
+declare global {
+    var internalFetch: typeof fetch;
+}
+export declare const handler: (...args: any[]) => any;

package/dist/adapters/server-adapter.js

@@ -0,0 +1,27 @@
+// We load every config here so that they are only loaded once
+// and during cold starts
+import { BuildId } from "./config/index.js";
+import { createMainHandler } from "../core/createMainHandler.js";
+import { setNodeEnv } from "./util.js";
+// We load every config here so that they are only loaded once
+// and during cold starts
+setNodeEnv();
+setBuildIdEnv();
+setNextjsServerWorkingDirectory();
+globalThis.internalFetch = fetch;
+/////////////
+// Handler //
+/////////////
+export const handler = await createMainHandler();
+//////////////////////
+// Helper functions //
+//////////////////////
+function setNextjsServerWorkingDirectory() {
+    // WORKAROUND: Set `NextServer` working directory (AWS specific) — https://github.com/serverless-stack/open-next#workaround-set-nextserver-working-directory-aws-specific
+    process.chdir(__dirname);
+}
+function setBuildIdEnv() {
+    // This allows users to access the CloudFront invalidating path when doing on-demand
+    // invalidations. ie. `/_next/data/${process.env.NEXT_BUILD_ID}/foo.json`
+    process.env.NEXT_BUILD_ID = BuildId;
+}

package/dist/adapters/util.d.ts

@@ -0,0 +1,10 @@
+export declare function setNodeEnv(): void;
+export declare function generateUniqueId(): string;
+/**
+ * Create an array of arrays of size `chunkSize` from `items`
+ * @param items Array of T
+ * @param chunkSize size of each chunk
+ * @returns T[][]
+ */
+export declare function chunk<T>(items: T[], chunkSize: number): T[][];
+export declare function parseNumberFromEnv(envValue: string | undefined): number | undefined;

package/dist/adapters/util.js

@@ -0,0 +1,28 @@
+//TODO: We should probably move all the utils to a separate location
+export function setNodeEnv() {
+    process.env.NODE_ENV = process.env.NODE_ENV ?? "production";
+}
+export function generateUniqueId() {
+    return Math.random().toString(36).slice(2, 8);
+}
+/**
+ * Create an array of arrays of size `chunkSize` from `items`
+ * @param items Array of T
+ * @param chunkSize size of each chunk
+ * @returns T[][]
+ */
+export function chunk(items, chunkSize) {
+    const chunked = items.reduce((acc, curr, i) => {
+        const chunkIndex = Math.floor(i / chunkSize);
+        acc[chunkIndex] = [...(acc[chunkIndex] ?? []), curr];
+        return acc;
+    }, new Array());
+    return chunked;
+}
+export function parseNumberFromEnv(envValue) {
+    if (typeof envValue !== "string") {
+        return envValue;
+    }
+    const parsedValue = parseInt(envValue);
+    return isNaN(parsedValue) ? undefined : parsedValue;
+}

package/dist/adapters/warmer-function.d.ts

@@ -0,0 +1,12 @@
+export interface WarmerEvent {
+    type: "warmer";
+    warmerId: string;
+    index: number;
+    concurrency: number;
+    delay: number;
+}
+export interface WarmerResponse {
+    type: "warmer";
+    serverId: string;
+}
+export declare const handler: (...args: any[]) => any;

package/dist/adapters/warmer-function.js

@@ -0,0 +1,80 @@
+import { createGenericHandler } from "../core/createGenericHandler.js";
+import { debug, error } from "./logger.js";
+import { generateUniqueId } from "./util.js";
+const resolveWarmerInvoke = async () => {
+    const openNextParams = globalThis.openNextConfig.warmer;
+    if (typeof openNextParams?.invokeFunction === "function") {
+        return await openNextParams.invokeFunction();
+    }
+    else {
+        return Promise.resolve({
+            name: "aws-invoke",
+            invoke: async (warmerId) => {
+                const { InvokeCommand, LambdaClient } = await import("@aws-sdk/client-lambda");
+                const lambda = new LambdaClient({});
+                const warmParams = JSON.parse(process.env.WARM_PARAMS);
+                for (const warmParam of warmParams) {
+                    const { concurrency: CONCURRENCY, function: FUNCTION_NAME } = warmParam;
+                    debug({
+                        event: "warmer invoked",
+                        functionName: FUNCTION_NAME,
+                        concurrency: CONCURRENCY,
+                        warmerId,
+                    });
+                    const ret = await Promise.all(Array.from({ length: CONCURRENCY }, (_v, i) => i).map((i) => {
+                        try {
+                            return lambda.send(new InvokeCommand({
+                                FunctionName: FUNCTION_NAME,
+                                InvocationType: "RequestResponse",
+                                Payload: Buffer.from(JSON.stringify({
+                                    type: "warmer",
+                                    warmerId,
+                                    index: i,
+                                    concurrency: CONCURRENCY,
+                                    delay: 75,
+                                })),
+                            }));
+                        }
+                        catch (e) {
+                            error(`failed to warm up #${i}`, e);
+                            // ignore error
+                        }
+                    }));
+                    // Print status
+                    const warmedServerIds = ret
+                        .map((r, i) => {
+                        if (r?.StatusCode !== 200 || !r?.Payload) {
+                            error(`failed to warm up #${i}:`, r?.Payload?.toString());
+                            return;
+                        }
+                        const payload = JSON.parse(Buffer.from(r.Payload).toString());
+                        return {
+                            statusCode: r.StatusCode,
+                            payload,
+                            type: "warmer",
+                        };
+                    })
+                        .filter((r) => !!r);
+                    debug({
+                        event: "warmer result",
+                        sent: CONCURRENCY,
+                        success: warmedServerIds.length,
+                        uniqueServersWarmed: [...new Set(warmedServerIds)].length,
+                    });
+                }
+            },
+        });
+    }
+};
+export const handler = await createGenericHandler({
+    handler: defaultHandler,
+    type: "warmer",
+});
+async function defaultHandler() {
+    const warmerId = `warmer-${generateUniqueId()}`;
+    const invokeFn = await resolveWarmerInvoke();
+    await invokeFn.invoke(warmerId);
+    return {
+        type: "warmer",
+    };
+}

package/dist/build/bundleNextServer.d.ts

@@ -0,0 +1 @@
+export declare function bundleNextServer(outputDir: string, appPath: string): Promise<void>;

package/dist/build/bundleNextServer.js

@@ -0,0 +1,87 @@
+import { createRequire as topLevelCreateRequire } from "node:module";
+import { build } from "esbuild";
+import path from "path";
+const externals = [
+    // This one was causing trouble, don't know why
+    "../experimental/testmode/server",
+    // sharedExternals
+    "styled-jsx",
+    "styled-jsx/style",
+    "@opentelemetry/api",
+    "next/dist/compiled/@next/react-dev-overlay/dist/middleware",
+    "next/dist/compiled/@ampproject/toolbox-optimizer",
+    "next/dist/compiled/edge-runtime",
+    "next/dist/compiled/@edge-runtime/ponyfill",
+    "next/dist/compiled/undici",
+    "next/dist/compiled/raw-body",
+    "next/dist/server/capsize-font-metrics.json",
+    "critters",
+    "next/dist/compiled/node-html-parser",
+    "next/dist/compiled/compression",
+    "next/dist/compiled/jsonwebtoken",
+    "next/dist/compiled/@opentelemetry/api",
+    "next/dist/compiled/@mswjs/interceptors/ClientRequest",
+    "next/dist/compiled/ws",
+    // externalsMap
+    // In the config they replace it, but we don't use this one inside NextServer anymore 13.4.12+
+    // For earlier versions we might have to alias it
+    "./web/sandbox",
+    // pagesExternal
+    "react",
+    "react-dom",
+    "react-server-dom-webpack",
+    "react-server-dom-turbopack",
+    // We need to remove this since this is what webpack is building
+    // Adding it cause to add a lot of unnecessary deps
+    "next/dist/compiled/next-server",
+];
+export async function bundleNextServer(outputDir, appPath) {
+    const require = topLevelCreateRequire(`${appPath}/package.json`);
+    const entrypoint = require.resolve("next/dist/esm/server/next-server.js");
+    await build({
+        entryPoints: [entrypoint],
+        bundle: true,
+        platform: "node",
+        target: ["node18"],
+        // packages: "external",
+        format: "cjs",
+        external: externals,
+        minify: true,
+        outfile: path.join(outputDir, "next-server.runtime.prod.js"),
+        sourcemap: false,
+        plugins: [
+            {
+                name: "opennext-next-server",
+                setup(build) {
+                    // This was an attempt at reducing server bundle size
+                    // It might be the better way to go in the future
+                    build.onResolve({ filter: /\.\/module.compiled/ }, (args) => {
+                        const dir = args.resolveDir.split("/").slice(-1);
+                        return {
+                            path: path.join("next/dist/compiled/next-server/", `${dir}.runtime.prod.js`),
+                            external: true,
+                        };
+                    });
+                    build.onResolve({ filter: /[\\/]react-server\.node/ }, (args) => {
+                        return {
+                            path: args.path,
+                            external: true,
+                        };
+                    });
+                    build.onResolve({ filter: /vendored[\\/]rsc[\\/]entrypoints/ }, (args) => {
+                        return {
+                            path: args.path,
+                            external: true,
+                        };
+                    });
+                    build.onResolve({ filter: /\.external/ }, (args) => {
+                        return {
+                            path: args.path.replace(/\.\./, "next/dist"),
+                            external: true,
+                        };
+                    });
+                },
+            },
+        ],
+    });
+}

package/dist/build/compileConfig.d.ts

@@ -0,0 +1,3 @@
+import { OpenNextConfig } from "../types/open-next.js";
+export declare function compileOpenNextConfigNode(tempDir: string, openNextConfigPath?: string, nodeExternals?: string): string;
+export declare function compileOpenNextConfigEdge(tempDir: string, config: OpenNextConfig, openNextConfigPath?: string): void;

package/dist/build/compileConfig.js

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import path from "node:path";
+import { buildSync } from "esbuild";
+import logger from "../logger.js";
+export function compileOpenNextConfigNode(tempDir, openNextConfigPath, nodeExternals) {
+    const sourcePath = path.join(process.cwd(), openNextConfigPath ?? "open-next.config.ts");
+    const outputPath = path.join(tempDir, "open-next.config.mjs");
+    //Check if open-next.config.ts exists
+    if (!fs.existsSync(sourcePath)) {
+        //Create a simple open-next.config.mjs file
+        logger.debug("Cannot find open-next.config.ts. Using default config.");
+        fs.writeFileSync(outputPath, [
+            "var config = { default: { } };",
+            "var open_next_config_default = config;",
+            "export { open_next_config_default as default };",
+        ].join("\n"));
+    }
+    else {
+        buildSync({
+            entryPoints: [sourcePath],
+            outfile: outputPath,
+            bundle: true,
+            format: "esm",
+            target: ["node18"],
+            external: nodeExternals ? nodeExternals.split(",") : [],
+            platform: "node",
+            banner: {
+                js: [
+                    "import { createRequire as topLevelCreateRequire } from 'module';",
+                    "const require = topLevelCreateRequire(import.meta.url);",
+                    "import bannerUrl from 'url';",
+                    "const __dirname = bannerUrl.fileURLToPath(new URL('.', import.meta.url));",
+                ].join(""),
+            },
+        });
+    }
+    return outputPath;
+}
+export function compileOpenNextConfigEdge(tempDir, config, openNextConfigPath) {
+    const sourcePath = path.join(process.cwd(), openNextConfigPath ?? "open-next.config.ts");
+    const outputPath = path.join(tempDir, "open-next.config.edge.mjs");
+    // We need to check if the config uses the edge runtime at any point
+    // If it does, we need to compile it with the edge runtime
+    const usesEdgeRuntime = config.middleware?.external ||
+        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
+    }
+    else {
+        logger.info("Compiling open-next.config.ts for edge runtime.", outputPath);
+        buildSync({
+            entryPoints: [sourcePath],
+            outfile: outputPath,
+            bundle: true,
+            format: "esm",
+            target: ["es2020"],
+            conditions: ["worker", "browser"],
+            platform: "browser",
+            external: config.edgeExternals ?? [],
+        });
+        logger.info("Compiled open-next.config.ts for edge runtime.");
+    }
+}

package/dist/build/copyTracedFiles.d.ts

@@ -0,0 +1 @@
+export declare function copyTracedFiles(buildOutputPath: string, packagePath: string, outputDir: string, routes: string[], bundledNextServer: boolean): Promise<void>;

package/dist/build/copyTracedFiles.js

@@ -0,0 +1,207 @@
+import url from "node:url";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, readlinkSync, statSync, symlinkSync, writeFileSync, } from "fs";
+import path from "path";
+import logger from "../logger.js";
+const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
+function copyPatchFile(outputDir) {
+    const patchFile = path.join(__dirname, "patch", "patchedAsyncStorage.js");
+    const outputPatchFile = path.join(outputDir, "patchedAsyncStorage.cjs");
+    copyFileSync(patchFile, outputPatchFile);
+}
+export async function copyTracedFiles(buildOutputPath, packagePath, outputDir, routes, bundledNextServer) {
+    const tsStart = Date.now();
+    const dotNextDir = path.join(buildOutputPath, ".next");
+    const standaloneDir = path.join(dotNextDir, "standalone");
+    const standaloneNextDir = path.join(standaloneDir, packagePath, ".next");
+    const outputNextDir = path.join(outputDir, packagePath, ".next");
+    const extractFiles = (files, from = standaloneNextDir) => {
+        return files.map((f) => path.resolve(from, f));
+    };
+    // On next 14+, we might not have to include those files
+    // For next 13, we need to include them otherwise we get runtime error
+    const requiredServerFiles = JSON.parse(readFileSync(path.join(dotNextDir, bundledNextServer
+        ? "next-minimal-server.js.nft.json"
+        : "next-server.js.nft.json"), "utf8"));
+    const filesToCopy = new Map();
+    // Files necessary by the server
+    extractFiles(requiredServerFiles.files).forEach((f) => {
+        filesToCopy.set(f, f.replace(standaloneDir, outputDir));
+    });
+    // create directory for pages
+    if (existsSync(path.join(standaloneDir, ".next/server/pages"))) {
+        mkdirSync(path.join(outputNextDir, "server/pages"), {
+            recursive: true,
+        });
+    }
+    if (existsSync(path.join(standaloneDir, ".next/server/app"))) {
+        mkdirSync(path.join(outputNextDir, "server/app"), {
+            recursive: true,
+        });
+    }
+    mkdirSync(path.join(outputNextDir, "server/chunks"), {
+        recursive: true,
+    });
+    const computeCopyFilesForPage = (pagePath) => {
+        const fullFilePath = `server/${pagePath}.js`;
+        let requiredFiles;
+        try {
+            requiredFiles = JSON.parse(readFileSync(path.join(standaloneNextDir, `${fullFilePath}.nft.json`), "utf8"));
+        }
+        catch (e) {
+            if (existsSync(path.join(standaloneNextDir, fullFilePath))) {
+                //TODO: add a link to the docs
+                throw new Error(`
+--------------------------------------------------------------------------------
+${pagePath} cannot use the edge runtime.
+OpenNext requires edge runtime function to be defined in a separate function. 
+See the docs for more information on how to bundle edge runtime functions.
+--------------------------------------------------------------------------------
+        `);
+            }
+            else {
+                throw new Error(`
+--------------------------------------------------------------------------------
+We cannot find the route for ${pagePath}.
+File ${fullFilePath} does not exist
+--------------------------------------------------------------------------------`);
+            }
+        }
+        const dir = path.dirname(fullFilePath);
+        extractFiles(requiredFiles.files, path.join(standaloneNextDir, dir)).forEach((f) => {
+            filesToCopy.set(f, f.replace(standaloneDir, outputDir));
+        });
+        if (!existsSync(path.join(standaloneNextDir, `${fullFilePath}`))) {
+            throw new Error(`This error should only happen for static 404 and 500 page from page router. Report this if that's not the case.,
+        File ${fullFilePath} does not exist`);
+        }
+        filesToCopy.set(path.join(standaloneNextDir, fullFilePath), path.join(outputNextDir, fullFilePath));
+    };
+    const safeComputeCopyFilesForPage = (pagePath, alternativePath) => {
+        try {
+            computeCopyFilesForPage(pagePath);
+        }
+        catch (e) {
+            if (alternativePath) {
+                computeCopyFilesForPage(alternativePath);
+            }
+        }
+    };
+    const hasPageDir = routes.some((route) => route.startsWith("pages/"));
+    const hasAppDir = routes.some((route) => route.startsWith("app/"));
+    // We need to copy all the base files like _app, _document, _error, etc
+    // One thing to note, is that next try to load every routes that might be needed in advance
+    // So if you have a [slug].tsx at the root, this route will always be loaded for 1st level request
+    // along with _app and _document
+    if (hasPageDir) {
+        //Page dir
+        computeCopyFilesForPage("pages/_app");
+        computeCopyFilesForPage("pages/_document");
+        computeCopyFilesForPage("pages/_error");
+        // These files can be present or not depending on if the user uses getStaticProps
+        safeComputeCopyFilesForPage("pages/404");
+        safeComputeCopyFilesForPage("pages/500");
+    }
+    if (hasAppDir) {
+        //App dir
+        // In next 14.2.0, _not-found is at 'app/_not-found/page'
+        safeComputeCopyFilesForPage("app/_not-found", "app/_not-found/page");
+    }
+    //Files we actually want to include
+    routes.forEach((route) => {
+        computeCopyFilesForPage(route);
+    });
+    //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"))) {
+            return;
+        }
+        mkdirSync(path.dirname(to), { recursive: true });
+        let symlink = null;
+        // For pnpm symlink we need to do that
+        // see https://github.com/vercel/next.js/blob/498f342b3552d6fc6f1566a1cc5acea324ce0dec/packages/next/src/build/utils.ts#L1932
+        try {
+            symlink = readlinkSync(from);
+        }
+        catch (e) {
+            //Ignore
+        }
+        if (symlink) {
+            try {
+                symlinkSync(symlink, to);
+            }
+            catch (e) {
+                if (e.code !== "EEXIST") {
+                    throw e;
+                }
+            }
+        }
+        else {
+            copyFileSync(from, to);
+        }
+    });
+    readdirSync(standaloneNextDir).forEach((f) => {
+        if (statSync(path.join(standaloneNextDir, f)).isDirectory())
+            return;
+        copyFileSync(path.join(standaloneNextDir, f), path.join(outputNextDir, f));
+    });
+    // We then need to copy all the files at the root of server
+    mkdirSync(path.join(outputNextDir, "server"), { recursive: true });
+    readdirSync(path.join(standaloneNextDir, "server")).forEach((f) => {
+        if (statSync(path.join(standaloneNextDir, "server", f)).isDirectory())
+            return;
+        if (f !== "server.js") {
+            copyFileSync(path.join(standaloneNextDir, "server", f), path.join(path.join(outputNextDir, "server"), f));
+        }
+    });
+    // Copy patch file
+    copyPatchFile(path.join(outputDir, packagePath));
+    // TODO: Recompute all the files.
+    // vercel doesn't seem to do it, but it seems wasteful to have all those files
+    // we replace the pages-manifest.json with an empty one if we don't have a pages dir so that
+    // next doesn't try to load _app, _document
+    if (!hasPageDir) {
+        writeFileSync(path.join(outputNextDir, "server/pages-manifest.json"), "{}");
+    }
+    //TODO: Find what else we need to copy
+    const copyStaticFile = (filePath) => {
+        if (existsSync(path.join(standaloneNextDir, filePath))) {
+            mkdirSync(path.dirname(path.join(outputNextDir, filePath)), {
+                recursive: true,
+            });
+            copyFileSync(path.join(standaloneNextDir, filePath), path.join(outputNextDir, filePath));
+        }
+    };
+    // Get all the static files - Should be only for pages dir
+    // Ideally we would filter only those that might get accessed in this specific functions
+    // 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(standaloneNextDir, "server/pages-manifest.json"), "utf8")));
+        // Then we need to get all fallback: true dynamic routes html
+        const prerenderManifest = JSON.parse(readFileSync(path.join(standaloneNextDir, "prerender-manifest.json"), "utf8"));
+        const config = JSON.parse(readFileSync(path.join(standaloneNextDir, "required-server-files.json"), "utf8")).config;
+        const locales = config.i18n?.locales;
+        Object.values(prerenderManifest.dynamicRoutes).forEach((route) => {
+            if (typeof route.fallback === "string") {
+                if (locales) {
+                    locales.forEach((locale) => {
+                        staticFiles.push(`pages/${locale}${route.fallback}`);
+                    });
+                }
+                else {
+                    staticFiles.push(`pages${route.fallback}`);
+                }
+            }
+        });
+        staticFiles.forEach((f) => {
+            if (f.endsWith(".html")) {
+                copyStaticFile(`server/${f}`);
+            }
+        });
+    }
+    logger.debug("copyTracedFiles:", Date.now() - tsStart, "ms");
+}

package/dist/build/createServerBundle.d.ts

@@ -0,0 +1,3 @@
+import { OpenNextConfig } from "../types/open-next";
+import type { BuildOptions } from "./helper.js";
+export declare function createServerBundle(config: OpenNextConfig, options: BuildOptions): Promise<void>;