@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.0

package/dist/esm-node/plugins/analyze/utils.mjs

@@ -0,0 +1,64 @@
+import "node:module";
+import { JS_EXTENSIONS, getCommand, normalizeToPosixPath } from "@modern-js/utils";
+import { parse } from "es-module-lexer";
+import { transform } from "esbuild";
+import fs from "fs";
+import path from "path";
+const walkDirectory = (dir)=>fs.readdirSync(dir).reduce((previous, filename)=>{
+        const filePath = path.join(dir, filename);
+        if (fs.statSync(filePath).isDirectory()) return [
+            ...previous,
+            ...walkDirectory(filePath)
+        ];
+        return [
+            ...previous,
+            filePath
+        ];
+    }, []);
+const replaceWithAlias = (base, filePath, alias)=>{
+    if (filePath.includes(base)) return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
+    return filePath;
+};
+const parseModule = async ({ source, filename })=>{
+    let content = source;
+    if (JS_EXTENSIONS.some((ext)=>filename.endsWith(ext))) {
+        const ext = path.extname(filename);
+        const result = await transform(content, {
+            sourcefile: filename,
+            format: 'esm',
+            loader: '.ts' === ext ? 'ts' : '.tsx' === ext ? 'tsx' : '.jsx' === ext ? 'jsx' : 'js',
+            target: 'es2022',
+            tsconfigRaw: {
+                compilerOptions: {
+                    experimentalDecorators: true
+                }
+            }
+        });
+        content = result.code;
+    }
+    return await parse(content);
+};
+const getServerCombinedModuleFile = (internalDirectory, entryName)=>path.join(internalDirectory, entryName, 'server-loader-combined.js');
+const checkIsBuildCommands = ()=>{
+    const buildCommands = [
+        'dev',
+        'start',
+        'build',
+        'inspect',
+        'deploy',
+        'dev-worker'
+    ];
+    const command = getCommand();
+    return buildCommands.includes(command);
+};
+const checkIsServeCommand = ()=>{
+    const command = getCommand();
+    return 'serve' === command;
+};
+const isSubDirOrEqual = (parent, child)=>{
+    if (parent === child) return true;
+    const relative = path.relative(parent, child);
+    const isSubdir = relative && !relative.startsWith('..') && !path.isAbsolute(relative);
+    return Boolean(isSubdir);
+};
+export { checkIsBuildCommands, checkIsServeCommand, getServerCombinedModuleFile, isSubDirOrEqual, parseModule, replaceWithAlias, walkDirectory };

package/dist/esm-node/plugins/deploy/index.mjs

@@ -0,0 +1,44 @@
+import "node:module";
+import { provider } from "std-env";
+import { createGhPagesPreset } from "./platforms/gh-pages.mjs";
+import { createNetlifyPreset } from "./platforms/netlify.mjs";
+import { createNodePreset } from "./platforms/node.mjs";
+import { createVercelPreset } from "./platforms/vercel.mjs";
+import { getProjectUsage } from "./utils/index.mjs";
+const deployPresets = {
+    node: createNodePreset,
+    vercel: createVercelPreset,
+    netlify: createNetlifyPreset,
+    ghPages: createGhPagesPreset
+};
+async function getDeployPreset(appContext, modernConfig, deployTarget, api) {
+    const { appDirectory, distDirectory, metaName } = appContext;
+    const { useSSR, useAPI, useWebServer } = getProjectUsage(appDirectory, distDirectory, metaName);
+    const needModernServer = useSSR || useAPI || useWebServer;
+    const createPreset = deployPresets[deployTarget];
+    if (!createPreset) throw new Error(`Unknown deploy target: '${deployTarget}'. MODERNJS_DEPLOY should be 'node', 'vercel', or 'netlify'.`);
+    return createPreset({
+        appContext,
+        modernConfig,
+        needModernServer,
+        api
+    });
+}
+const deploy = ()=>({
+        name: '@modern-js/plugin-deploy',
+        setup: (api)=>{
+            const deployTarget = process.env.MODERNJS_DEPLOY || provider || 'node';
+            api.deploy(async ()=>{
+                const appContext = api.getAppContext();
+                const { metaName } = appContext;
+                if ('modern-js' !== metaName && !process.env.MODERNJS_DEPLOY) return;
+                const modernConfig = api.getNormalizedConfig();
+                const deployPreset = await getDeployPreset(appContext, modernConfig, deployTarget, api);
+                deployPreset?.prepare && await deployPreset?.prepare();
+                deployPreset?.writeOutput && await deployPreset?.writeOutput();
+                deployPreset?.genEntry && await deployPreset?.genEntry();
+                deployPreset?.end && await deployPreset?.end();
+            });
+        }
+    });
+export default deploy;

package/dist/esm-node/plugins/deploy/platforms/gh-pages.mjs

@@ -0,0 +1,44 @@
+import "node:module";
+import { fs, logger } from "@modern-js/utils";
+import path from "path";
+async function reorganizeHtmlFiles(routes, baseDir, baseUrl = '/') {
+    if (!routes || !Array.isArray(routes)) return void logger.error('Invalid server routes');
+    await fs.ensureDir(baseDir);
+    const baseUrlRegexp = new RegExp(`^${baseUrl}\\/?`);
+    const collectedEntryPaths = new Set();
+    const copyPromises = routes.map(async (route)=>{
+        const { urlPath, entryPath } = route;
+        if (!entryPath) return void logger.warn(`Route ${urlPath} does not specify entryPath, skipping`);
+        if (collectedEntryPaths.has(entryPath)) return;
+        collectedEntryPaths.add(entryPath);
+        const sourceHtmlPath = path.join(baseDir, entryPath);
+        if (!await fs.pathExists(sourceHtmlPath)) return void logger.error(`Source HTML file does not exist: ${sourceHtmlPath}`);
+        const targetDir = urlPath.replace(baseUrlRegexp, '');
+        await fs.ensureDir(path.dirname(targetDir));
+        const targetHtmlPath = path.join(baseDir, targetDir, 'index.html');
+        try {
+            await fs.move(sourceHtmlPath, targetHtmlPath);
+        } catch (error) {
+            logger.error(`Failed to copy HTML file: ${error.message}`);
+        }
+    });
+    await Promise.all(copyPromises);
+}
+const createGhPagesPreset = ({ appContext, modernConfig })=>{
+    const { serverRoutes, appDirectory, distDirectory } = appContext;
+    const { server: { baseUrl } } = modernConfig;
+    const outputDirectory = path.join(appDirectory, '.output');
+    return {
+        name: 'gh-pages',
+        async prepare () {
+            await fs.remove(outputDirectory);
+        },
+        async writeOutput () {
+            await fs.copy(distDirectory, outputDirectory);
+        },
+        async end () {
+            await reorganizeHtmlFiles(serverRoutes, outputDirectory, Array.isArray(baseUrl) ? baseUrl[0] : baseUrl);
+        }
+    };
+};
+export { createGhPagesPreset };

package/dist/esm-node/plugins/deploy/platforms/netlify.mjs

@@ -0,0 +1,98 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import node_path from "node:path";
+import { fs, removeModuleSyncFromExports } from "@modern-js/utils";
+import { nodeDepEmit } from "ndepe";
+import { isMainEntry } from "../../../utils/routes.mjs";
+import { readTemplate, resolveESMDependency } from "../utils/index.mjs";
+import { generateHandler } from "../utils/generator.mjs";
+async function cleanDistDirectory(dir) {
+    try {
+        const items = await fs.readdir(dir);
+        for (const item of items){
+            const fullPath = node_path.join(dir, item);
+            if ('static' !== item && '_redirects' !== item && 'html' !== item) await fs.remove(fullPath);
+        }
+    } catch (error) {
+        console.error('Error cleaning directory:', error);
+    }
+}
+const createNetlifyPreset = ({ appContext, modernConfig, needModernServer })=>{
+    const { appDirectory, distDirectory, entrypoints, moduleType } = appContext;
+    const isEsmProject = 'module' === moduleType;
+    const netlifyOutput = node_path.join(appDirectory, '.netlify');
+    const funcsDirectory = node_path.join(netlifyOutput, 'functions');
+    const entryFilePath = node_path.join(funcsDirectory, 'index.js');
+    return {
+        async prepare () {
+            await fs.remove(netlifyOutput);
+        },
+        async writeOutput () {
+            const routes = [];
+            const { source: { mainEntryName }, html: { outputStructure } } = modernConfig;
+            if (needModernServer) routes.push({
+                src: '/*',
+                dest: "/.netlify/functions/index",
+                status: 200
+            });
+            else entrypoints.forEach((entry)=>{
+                const isMain = isMainEntry(entry.entryName, mainEntryName);
+                const htmlPath = 'flat' === outputStructure ? `/html/${entry.entryName}.html` : `/html/${entry.entryName}/index.html`;
+                routes.push({
+                    src: `/${isMain ? '' : `${entry.entryName}/`}*`,
+                    dest: htmlPath,
+                    status: 200
+                });
+            });
+            const redirectContent = routes.map((route)=>`${route.src} ${route.dest} ${route.status}`).join('\n');
+            if (needModernServer) {
+                await fs.ensureDir(funcsDirectory);
+                await fs.copy(distDirectory, funcsDirectory, {
+                    filter: (src)=>{
+                        const distStaticDirectory = node_path.join(distDirectory, "static");
+                        return !src.includes(distStaticDirectory);
+                    }
+                });
+            }
+            const redirectFilePath = node_path.join(distDirectory, '_redirects');
+            await fs.writeFile(redirectFilePath, redirectContent);
+        },
+        async genEntry () {
+            if (!needModernServer) return;
+            const template = await readTemplate(`netlify-entry.${isEsmProject ? 'mjs' : 'cjs'}`);
+            const code = await generateHandler({
+                template,
+                appContext,
+                config: modernConfig,
+                isESM: isEsmProject
+            });
+            await fs.writeFile(entryFilePath, code);
+        },
+        async end () {
+            if ('development' !== process.env.NODE_ENV) await cleanDistDirectory(distDirectory);
+            if (!needModernServer) return;
+            const entry = isEsmProject ? await resolveESMDependency('@modern-js/prod-server') : require.resolve('@modern-js/prod-server');
+            const netlifyEntry = isEsmProject ? await resolveESMDependency('@modern-js/prod-server/netlify') : require.resolve('@modern-js/prod-server/netlify');
+            if (!entry || !netlifyEntry) throw new Error('Cannot find @modern-js/prod-server');
+            await nodeDepEmit({
+                appDir: appDirectory,
+                sourceDir: funcsDirectory,
+                includeEntries: [
+                    entry,
+                    netlifyEntry
+                ],
+                copyWholePackage (pkgName) {
+                    return '@modern-js/utils' === pkgName;
+                },
+                transformPackageJson: ({ pkgJSON })=>{
+                    if (!pkgJSON.exports || 'object' != typeof pkgJSON.exports) return pkgJSON;
+                    return {
+                        ...pkgJSON,
+                        exports: removeModuleSyncFromExports(pkgJSON.exports)
+                    };
+                }
+            });
+        }
+    };
+};
+export { createNetlifyPreset };

package/dist/esm-node/plugins/deploy/platforms/node.mjs

@@ -0,0 +1,58 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import node_path from "node:path";
+import { chalk, fs, removeModuleSyncFromExports } from "@modern-js/utils";
+import { nodeDepEmit } from "ndepe";
+import { readTemplate, resolveESMDependency } from "../utils/index.mjs";
+import { generateHandler } from "../utils/generator.mjs";
+const createNodePreset = ({ appContext, modernConfig, api })=>{
+    const { appDirectory, distDirectory, moduleType } = appContext;
+    const isEsmProject = 'module' === moduleType;
+    const outputDirectory = node_path.join(appDirectory, '.output');
+    const staticDirectory = node_path.join(outputDirectory, 'static');
+    const entryFilePath = node_path.join(outputDirectory, 'index.js');
+    return {
+        async prepare () {
+            await fs.remove(outputDirectory);
+        },
+        async writeOutput () {
+            await fs.copy(distDirectory, outputDirectory);
+        },
+        async genEntry () {
+            const template = await readTemplate(`node-entry.${isEsmProject ? 'mjs' : 'cjs'}`);
+            const code = await generateHandler({
+                template,
+                appContext,
+                config: modernConfig,
+                isESM: isEsmProject
+            });
+            await fs.writeFile(entryFilePath, code);
+        },
+        async end () {
+            const filter = (filePath)=>!filePath.startsWith(staticDirectory) && !filePath.endsWith('.map');
+            const entry = isEsmProject ? await resolveESMDependency('@modern-js/prod-server') : require.resolve('@modern-js/prod-server');
+            if (!entry) throw new Error('Cannot find @modern-js/prod-server');
+            await nodeDepEmit({
+                appDir: appDirectory,
+                sourceDir: outputDirectory,
+                includeEntries: [
+                    entry
+                ],
+                copyWholePackage (pkgName) {
+                    return '@modern-js/utils' === pkgName;
+                },
+                entryFilter: filter,
+                transformPackageJson: ({ pkgJSON })=>{
+                    if (!pkgJSON.exports) return pkgJSON;
+                    return {
+                        ...pkgJSON,
+                        exports: removeModuleSyncFromExports(pkgJSON.exports)
+                    };
+                }
+            });
+            console.log('Static directory:', chalk.blue(node_path.relative(appDirectory, staticDirectory).replace(/\\/g, '/')));
+            console.log("You can preview this build by", chalk.blue('node .output/index'));
+        }
+    };
+};
+export { createNodePreset };

package/dist/esm-node/plugins/deploy/platforms/platform.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/plugins/deploy/platforms/templates/netlify-entry.cjs

@@ -0,0 +1,57 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { createNetlifyFunction } = require('@modern-js/prod-server/netlify');
+p_genPluginImportsCode;
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+let requestHandler = null;
+let handlerCreationPromise = null;
+async function loadRoutes(routeFilepath) {
+    try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, 'utf-8');
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+    } catch (error) {
+        console.warn('route.json not found or invalid, continuing with empty routes.');
+        return [];
+    }
+}
+async function initServer() {
+    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+    const routes = await loadRoutes(routeFilepath);
+    const dynamicProdOptions = p_dynamicProdOptions;
+    const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+            sharedDirectory: p_sharedDirectory,
+            apiDirectory: p_apiDirectory,
+            lambdaDirectory: p_lambdaDirectory,
+            bffRuntimeFramework: p_bffRuntimeFramework
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const requestHandler = await createNetlifyFunction(prodServerOptions);
+    return requestHandler;
+}
+async function createHandler() {
+    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
+        try {
+            requestHandler = await initServer();
+        } catch (error) {
+            console.error('Error creating server:', error);
+            process.exit(1);
+        }
+    })();
+    await handlerCreationPromise;
+    return requestHandler;
+}
+createHandler();
+const handler = async (request, context)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(request, context);
+};
+module.exports.default = handler;

package/dist/esm-node/plugins/deploy/platforms/templates/netlify-entry.mjs

@@ -0,0 +1,59 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createNetlifyFunction } from '@modern-js/prod-server/netlify';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+p_genPluginImportsCode;
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+let requestHandler = null;
+let handlerCreationPromise = null;
+async function loadRoutes(routeFilepath) {
+    try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, 'utf-8');
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+    } catch (error) {
+        console.warn('route.json not found or invalid, continuing with empty routes.');
+        return [];
+    }
+}
+async function initServer() {
+    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+    const routes = await loadRoutes(routeFilepath);
+    const dynamicProdOptions = p_dynamicProdOptions;
+    const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+            sharedDirectory: p_sharedDirectory,
+            apiDirectory: p_apiDirectory,
+            lambdaDirectory: p_lambdaDirectory,
+            bffRuntimeFramework: p_bffRuntimeFramework
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const requestHandler = await createNetlifyFunction(prodServerOptions);
+    return requestHandler;
+}
+async function createHandler() {
+    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
+        try {
+            requestHandler = await initServer();
+        } catch (error) {
+            console.error('Error creating server:', error);
+            process.exit(1);
+        }
+    })();
+    await handlerCreationPromise;
+    return requestHandler;
+}
+createHandler();
+const handler = async (request, context)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(request, context);
+};
+export default handler;

package/dist/esm-node/plugins/deploy/platforms/templates/node-entry.cjs

@@ -0,0 +1,44 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { createProdServer } = require('@modern-js/prod-server');
+p_genPluginImportsCode;
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+async function loadRoutes(routeFilepath) {
+    try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, 'utf-8');
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+    } catch (error) {
+        console.warn('route.json not found or invalid, continuing with empty routes.');
+        return [];
+    }
+}
+async function main() {
+    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+    const routes = await loadRoutes(routeFilepath);
+    const dynamicProdOptions = p_dynamicProdOptions;
+    const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+            sharedDirectory: p_sharedDirectory,
+            apiDirectory: p_apiDirectory,
+            lambdaDirectory: p_lambdaDirectory,
+            bffRuntimeFramework: p_bffRuntimeFramework
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const app = await createProdServer(prodServerOptions);
+    const port = process.env.PORT || 8080;
+    app.listen({
+        host: '::',
+        port
+    }, ()=>{
+        console.log(`\x1b[32mServer is listening on http://[::]:${port}`, '\x1b[0m');
+    });
+}
+main();

package/dist/esm-node/plugins/deploy/platforms/templates/node-entry.mjs

@@ -0,0 +1,46 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createProdServer } from '@modern-js/prod-server';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+p_genPluginImportsCode;
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+async function loadRoutes(routeFilepath) {
+    try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, 'utf-8');
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+    } catch (error) {
+        console.warn('route.json not found or invalid, continuing with empty routes.');
+        return [];
+    }
+}
+async function main() {
+    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+    const routes = await loadRoutes(routeFilepath);
+    const dynamicProdOptions = p_dynamicProdOptions;
+    const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+            sharedDirectory: p_sharedDirectory,
+            apiDirectory: p_apiDirectory,
+            lambdaDirectory: p_lambdaDirectory,
+            bffRuntimeFramework: p_bffRuntimeFramework
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const app = await createProdServer(prodServerOptions);
+    const port = process.env.PORT || 8080;
+    app.listen({
+        host: '::',
+        port
+    }, ()=>{
+        console.log(`\x1b[32mServer is listening on http://[::]:${port}`, '\x1b[0m');
+    });
+}
+main();

package/dist/esm-node/plugins/deploy/platforms/templates/vercel-entry.cjs

@@ -0,0 +1,57 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { createProdServer } = require('@modern-js/prod-server');
+p_genPluginImportsCode;
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+let requestHandler = null;
+let handlerCreationPromise = null;
+async function loadRoutes(routeFilepath) {
+    try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, 'utf-8');
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+    } catch (error) {
+        console.warn('route.json not found or invalid, continuing with empty routes.');
+        return [];
+    }
+}
+async function initServer() {
+    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+    const routes = await loadRoutes(routeFilepath);
+    const dynamicProdOptions = p_dynamicProdOptions;
+    const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+            sharedDirectory: p_sharedDirectory,
+            apiDirectory: p_apiDirectory,
+            lambdaDirectory: p_lambdaDirectory,
+            bffRuntimeFramework: p_bffRuntimeFramework
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const app = await createProdServer(prodServerOptions);
+    return app.getRequestListener();
+}
+async function createHandler() {
+    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
+        try {
+            requestHandler = await initServer();
+        } catch (error) {
+            console.error('Error creating server:', error);
+            process.exit(1);
+        }
+    })();
+    await handlerCreationPromise;
+    return requestHandler;
+}
+createHandler();
+const handler = async (req, res)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(req, res);
+};
+module.exports = handler;

package/dist/esm-node/plugins/deploy/platforms/templates/vercel-entry.mjs

@@ -0,0 +1,58 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createProdServer } from '@modern-js/prod-server';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+p_genPluginImportsCode;
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+let requestHandler = null;
+let handlerCreationPromise = null;
+async function loadRoutes(routeFilepath) {
+    try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, 'utf-8');
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+    } catch (error) {
+        console.warn('route.json not found or invalid, continuing with empty routes.');
+        return [];
+    }
+}
+async function initServer() {
+    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+    const routes = await loadRoutes(routeFilepath);
+    const dynamicProdOptions = p_dynamicProdOptions;
+    const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+            sharedDirectory: p_sharedDirectory,
+            apiDirectory: p_apiDirectory,
+            lambdaDirectory: p_lambdaDirectory
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const app = await createProdServer(prodServerOptions);
+    return app.getRequestListener();
+}
+async function createHandler() {
+    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
+        try {
+            requestHandler = await initServer();
+        } catch (error) {
+            console.error('Error creating server:', error);
+            process.exit(1);
+        }
+    })();
+    await handlerCreationPromise;
+    return requestHandler;
+}
+createHandler();
+const handler = async (req, res)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(req, res);
+};
+export default handler;