@bleedingdev/modern-js-app-tools 3.8.2-ultramodern.9 → 3.8.3-ultramodern.2

package/dist/esm/builder/shared/builderPlugins/adapterSSR.mjs

@@ -1,21 +1,31 @@
+import { CssExtractRuntimePlugin } from "@modern-js/app-tools-extensions";
 import { SERVICE_WORKER_ENVIRONMENT_NAME, isHtmlDisabled } from "@modern-js/builder";
-import { fs, isUseRsc, isUseSSRBundle } from "@modern-js/utils";
+import { fs, isUseRsc, isUseSSRBundle, logger } from "@modern-js/utils";
 import { mergeRsbuildConfig } from "@rsbuild/core";
 import { getServerCombinedModuleFile } from "../../../plugins/analyze/utils.mjs";
-import { CssExtractRuntimePlugin, HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins/index.mjs";
+import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins/index.mjs";
+import { aggregateEagerRouteComponentFiles, planSSRLazyCompilation } from "../lazyCompilation.mjs";
 import * as __rspack_external_path from "path";
 const builderPluginAdapterSSR = (options)=>({
         name: 'builder-plugin-adapter-modern-ssr',
         setup (api) {
-            const { normalizedConfig, appContext } = options;
-            api.modifyRsbuildConfig((config)=>mergeRsbuildConfig(config, {
+            const { normalizedConfig, appContext, eagerRouteComponentFilesByEntry } = options;
+            api.modifyRsbuildConfig((config)=>{
+                const merged = mergeRsbuildConfig(config, {
                     html: {
                         inject: isStreamingSSR(normalizedConfig) ? 'head' : void 0
                     },
                     server: {
                         compress: isStreamingSSR(normalizedConfig) || isUseRsc(normalizedConfig) ? false : void 0
                     }
-                }));
+                });
+                const lazyCompilation = getSSRLazyCompilation(merged.dev?.lazyCompilation, normalizedConfig, appContext, eagerRouteComponentFilesByEntry);
+                if (void 0 !== lazyCompilation) merged.dev = {
+                    ...merged.dev,
+                    lazyCompilation
+                };
+                return merged;
+            });
             api.modifyBundlerChain(async (chain, { target, isProd, HtmlPlugin: HtmlBundlerPlugin, isServer, environment })=>{
                 const builderConfig = environment.config;
                 const { normalizedConfig } = options;
@@ -51,6 +61,22 @@ const isStreamingSSR = (userConfig)=>{
     }
     return false;
 };
+function getSSRLazyCompilation(current, normalizedConfig, appContext, eagerRouteComponentFilesByEntry) {
+    if (!current || isUseRsc(normalizedConfig) || !isStreamingSSR(normalizedConfig)) return;
+    const plan = planSSRLazyCompilation(current, aggregateEagerRouteComponentFiles(eagerRouteComponentFilesByEntry));
+    if (!plan.apply) {
+        if (plan.unresolvedByEntry) warnUnresolvedRouteComponents(appContext.appDirectory, plan.unresolvedByEntry);
+        return;
+    }
+    return plan.lazyCompilation;
+}
+const warnedLazyApps = new Set();
+function warnUnresolvedRouteComponents(appDirectory, unresolvedByEntry) {
+    if (warnedLazyApps.has(appDirectory)) return;
+    warnedLazyApps.add(appDirectory);
+    const detail = Array.from(unresolvedByEntry).map(([entry, comps])=>`${entry}: ${comps.join(', ')}`).join('; ');
+    logger.warn(`[lazyCompilation] Skipped stream SSR route-eager optimization because some route components could not be resolved to a file (${detail}). Lazy compilation may break first-screen CSS/JS for these routes.`);
+}
 function applyAsyncChunkHtmlPlugin({ chain, modernConfig, HtmlBundlerPlugin }) {
     if (isStreamingSSR(modernConfig) || isUseRsc(modernConfig)) chain.plugin('html-async-chunk').use(HtmlAsyncChunkPlugin, [
         HtmlBundlerPlugin
@@ -98,10 +124,9 @@ function applyFilterEntriesBySSRConfig({ isProd, chain, appNormalizedConfig }) {
     });
 }
 async function applySSRLoaderEntry(chain, optinos, isServer) {
-    const { appContext, normalizedConfig } = optinos;
+    const { appContext } = optinos;
     const { internalDirectory } = appContext;
     const { entrypoints } = appContext;
-    const isRsc = isUseRsc(normalizedConfig);
     await Promise.all(entrypoints.map(async (entrypoint)=>{
         const { entryName } = entrypoint;
         const serverLoadersFile = getServerCombinedModuleFile(internalDirectory, entryName);
@@ -109,7 +134,7 @@ async function applySSRLoaderEntry(chain, optinos, isServer) {
             await fs.access(serverLoadersFile, fs.constants.F_OK);
             chain.entry(`${entryName}-server-loaders`).add(serverLoadersFile);
         } catch (err) {}
-        else if (isRsc) chain.entry(`${entryName}-server-loaders`).add("data:text/javascript,export%20{};");
+        else if (isUseRsc(optinos.normalizedConfig)) chain.entry(`${entryName}-server-loaders`).add("data:text/javascript,export%20{};");
     }));
 }
 function applySSRDataLoader(chain, options) {
@@ -120,4 +145,4 @@ function applySSRDataLoader(chain, options) {
     const reg = new RegExp(`${absolutePath}.*\\.(loader|data|data.client)\\.[t|j]sx?$`);
     chain.module.rule('ssr-data-loader').test(reg).use('data-loader').loader(require.resolve('@modern-js/plugin-data-loader/loader')).end();
 }
-export { builderPluginAdapterSSR };
+export { builderPluginAdapterSSR, getSSRLazyCompilation };

package/dist/esm/builder/shared/builderPlugins/index.mjs

@@ -1,6 +1,5 @@
 export * from "./adapterBasic.mjs";
 export * from "./adapterHtml.mjs";
-export * from "./adapterLazyCompilation.mjs";
 export * from "./adapterPrecompress.mjs";
 export * from "./adapterSSR.mjs";
 export * from "./builderHooks.mjs";

package/dist/esm/builder/shared/bundlerPlugins/index.mjs

@@ -1,4 +1,3 @@
-export * from "./CssExtractRuntimePlugin.mjs";
 export * from "./HtmlAsyncChunkPlugin.mjs";
 export * from "./HtmlBottomTemplate.mjs";
 export * from "./RouterPlugin.mjs";

package/dist/esm/builder/shared/lazyCompilation.mjs

@@ -11,7 +11,7 @@ function aggregateEagerRouteComponentFiles(byEntry) {
         unresolvedByEntry
     };
 }
-function buildRouteEagerLazyCompilationTest(eagerRouteFiles, userTest) {
+function buildSSRLazyCompilationTest(eagerRouteFiles, userTest) {
     const userTestFn = 'function' == typeof userTest ? userTest : userTest instanceof RegExp ? (m)=>userTest.test(m.resource || '') : ()=>true;
     return (m)=>{
         const resource = m.resource;
@@ -20,7 +20,7 @@ function buildRouteEagerLazyCompilationTest(eagerRouteFiles, userTest) {
         return userTestFn(m);
     };
 }
-function planRouteEagerLazyCompilation(current, info) {
+function planSSRLazyCompilation(current, info) {
     if (!current) return {
         apply: false
     };
@@ -37,8 +37,8 @@ function planRouteEagerLazyCompilation(current, info) {
         apply: true,
         lazyCompilation: {
             ...base,
-            test: buildRouteEagerLazyCompilationTest(info.files, userTest)
+            test: buildSSRLazyCompilationTest(info.files, userTest)
         }
     };
 }
-export { aggregateEagerRouteComponentFiles, buildRouteEagerLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planRouteEagerLazyCompilation };
+export { aggregateEagerRouteComponentFiles, buildSSRLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planSSRLazyCompilation };

package/dist/esm/bundleDocs.mjs

@@ -21,7 +21,7 @@ function bundleDocs({ source, target, indexFile = DEFAULT_INDEX_FILE, excludedDi
         withFileTypes: true
     })){
         if (!entry.isFile()) continue;
-        const from = node_path.join(entry.parentPath ?? entry.path, entry.name);
+        const from = node_path.join(entry.parentPath, entry.name);
         const rel = node_path.relative(source, from);
         if (!isBundled(rel)) continue;
         const to = node_path.join(target, rel);

package/dist/esm/index.mjs

@@ -1,3 +1,4 @@
+import { createCloudflareBuilderPlugin } from "@modern-js/app-tools-extensions/cloudflare-builder";
 import { castArray } from "@modern-js/builder";
 import { getLocaleLanguage } from "@modern-js/i18n-utils/language-detector";
 import { createAsyncHook } from "@modern-js/plugin";
@@ -13,7 +14,6 @@ import deploy from "./plugins/deploy/index.mjs";
 import initialize from "./plugins/initialize/index.mjs";
 import serverBuild from "./plugins/serverBuild.mjs";
 import serverRuntime from "./plugins/serverRuntime.mjs";
-import ultramodernReleaseEnvelope from "./plugins/ultramodernReleaseEnvelope.mjs";
 import { generateWatchFiles } from "./utils/generateWatchFiles.mjs";
 import { initAppContext } from "./utils/initAppContext.mjs";
 import { restart } from "./utils/restart.mjs";
@@ -29,8 +29,8 @@ const appTools = ()=>({
             analyze(),
             serverBuild(),
             backendFederationBuild(),
-            ultramodernReleaseEnvelope(),
-            deploy()
+            deploy(),
+            createCloudflareBuilderPlugin()
         ],
         post: [
             '@modern-js/plugin-initialize',

package/dist/esm/plugins/analyze/getServerRoutes.mjs

@@ -1,4 +1,4 @@
-import { ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, SERVER_WORKER_BUNDLE_DIRECTORY, fs, getEntryOptions, isPlainObject, removeLeadingSlash, removeTailSlash, urlJoin } from "@modern-js/utils";
+import { MAIN_ENTRY_NAME, ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, SERVER_WORKER_BUNDLE_DIRECTORY, fs, getEntryOptions, isPlainObject, removeLeadingSlash, removeTailSlash, urlJoin } from "@modern-js/utils";
 import path from "path";
 import { isMainEntry } from "../../utils/routes.mjs";
 import { walkDirectory } from "./utils.mjs";

package/dist/esm/plugins/analyze/isDefaultExportFunction.mjs

@@ -10,23 +10,15 @@ const isDefaultExportFunction = (file)=>{
         plugins: [
             'jsx',
             "typescript",
-            'classProperties',
-            'dynamicImport',
             'exportDefaultFrom',
-            'exportNamespaceFrom',
             'decorators-legacy',
             'functionBind',
-            'classPrivateMethods',
             [
                 'pipelineOperator',
                 {
                     proposal: 'fsharp'
                 }
-            ],
-            'optionalChaining',
-            'optionalCatchBinding',
-            'objectRestSpread',
-            'numericSeparator'
+            ]
         ]
     });
     let isExportFunction = false;

package/dist/esm/plugins/backend-federation/codegen.mjs

@@ -98,7 +98,7 @@ module.exports = { __modernjsBackendFederation, get, init };
     if (!output) throw new Error('[backend-federation-build] CommonJS backend federation container emitted no output.');
     return output.text;
 };
-const createBackendManifest = (workspaceRoot, distDirectory, app)=>{
+const createBackendManifest = (workspaceRoot, distDirectory, app, entryIntegrity)=>{
     const sourceModule = `${app.directory}/api/effect-api.ts`;
     const publicPath = createPublicPath(app.containerEntry, app.port);
     const manifest = {
@@ -129,6 +129,7 @@ const createBackendManifest = (workspaceRoot, distDirectory, app)=>{
             ssrPublicPath: publicPath
         },
         entry: {
+            ...entryIntegrity,
             file: BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
             path: normalizeRelativePath(node_path.relative(workspaceRoot, node_path.join(distDirectory, BACKEND_FEDERATION_REMOTE_ENTRY_FILE))),
             type: app.remoteType,

package/dist/esm/plugins/backend-federation/config.mjs

@@ -1,8 +1,8 @@
 import { existsSync } from "node:fs";
 import promises from "node:fs/promises";
 import node_path from "node:path";
+import { resolveUltramodernSourceRevision } from "@modern-js/app-tools-extensions/release-identity";
 import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION, ULTRAMODERN_BUILD_ARTIFACT_FILE, ULTRAMODERN_BUILD_ARTIFACT_PATH, ULTRAMODERN_BUILD_MODULE_PATH, deliveryUnitContractBlock, isUltramodernBuildArtifact, validateDeliveryUnitRecord, validateUltramodernBuildArtifact } from "@modern-js/utils/universal";
-import { resolveUltramodernSourceRevision } from "../../ultramodern-release-identity.mjs";
 const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
 const normalizeRelativePath = (value)=>value.replace(/\\/gu, '/').replace(/^\.\/+/u, '');
 const isRecord = (value)=>'object' == typeof value && null !== value;

package/dist/esm/plugins/backend-federation/emit.mjs

@@ -1,8 +1,9 @@
 import { existsSync } from "node:fs";
 import promises from "node:fs/promises";
 import node_path from "node:path";
+import { resolveUltramodernReleaseIdentity } from "@modern-js/app-tools-extensions/release-identity";
+import { createBackendFederationEntryIntegrity } from "@modern-js/server-runtime-extensions/backend-federation-security/node";
 import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE, stampUltramodernBuildArtifactIdentity } from "@modern-js/utils/universal";
-import { resolveUltramodernReleaseIdentity } from "../../ultramodern-release-identity.mjs";
 import { createBackendManifest, createBackendRemoteEntrySource } from "./codegen.mjs";
 import { COMPACT_CONFIG_PATH, buildArtifactPathFor, buildModulePathFor, createStampedDeliveryUnit, findBackendFederationApp, findWorkspaceRoot, readBuildIdentity, resolveWorkspaceSourceRevision } from "./config.mjs";
 const emitBackendFederationArtifacts = async (appDirectory, distDirectory)=>{
@@ -67,11 +68,12 @@ const emitBackendFederationArtifacts = async (appDirectory, distDirectory)=>{
     const manifestPath = node_path.join(distDirectory, BACKEND_FEDERATION_MANIFEST_FILE);
     const entryPath = node_path.join(distDirectory, BACKEND_FEDERATION_REMOTE_ENTRY_FILE);
     const deliveryUnitArtifactPath = stampedBuildArtifact ? node_path.join(distDirectory, ULTRAMODERN_BUILD_ARTIFACT_FILE) : void 0;
+    const entrySource = await createBackendRemoteEntrySource(workspaceRoot, resolvedApp, effectApiPath, entryPath);
     await promises.mkdir(distDirectory, {
         recursive: true
     });
-    await promises.writeFile(entryPath, await createBackendRemoteEntrySource(workspaceRoot, resolvedApp, effectApiPath, entryPath));
-    await promises.writeFile(manifestPath, `${JSON.stringify(createBackendManifest(workspaceRoot, distDirectory, resolvedApp), null, 2)}\n`);
+    await promises.writeFile(entryPath, entrySource);
+    await promises.writeFile(manifestPath, `${JSON.stringify(createBackendManifest(workspaceRoot, distDirectory, resolvedApp, createBackendFederationEntryIntegrity(entrySource)), null, 2)}\n`);
     if (stampedBuildArtifact && deliveryUnitArtifactPath) await promises.writeFile(deliveryUnitArtifactPath, `${JSON.stringify(stampedBuildArtifact, null, 2)}\n`);
     return {
         appId: resolvedApp.id,

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

@@ -1,5 +1,5 @@
+import { createCloudflarePreset } from "@modern-js/app-tools-extensions/cloudflare";
 import { provider } from "std-env";
-import { createCloudflarePreset } from "./platforms/cloudflare/index.mjs";
 import { createGhPagesPreset } from "./platforms/gh-pages.mjs";
 import { createNetlifyPreset } from "./platforms/netlify.mjs";
 import { createNodePreset } from "./platforms/node.mjs";

package/dist/esm/plugins/deploy/platforms/cloudflare-output-verifier/index.mjs

@@ -1,133 +1 @@
-import promises from "node:fs/promises";
-import node_path from "node:path";
-import { createCloudflareOutputPlan } from "../cloudflare-output-plan.mjs";
-import { verifyDeliveryUnitIdentity } from "./identity.mjs";
-import { addIssue, assertEqual, assertFlag } from "./issues.mjs";
-import { verifyManifestShape } from "./manifest.mjs";
-import { getEffectBffWorker, getWorkerBundleReferences, missingWorkerBundleMessage, resolveWorkerBundleReference, verifyWorkerBundleReferences, verifyWorkerImport } from "./worker-bundles.mjs";
-const pathExists = async (filePath)=>{
-    try {
-        await promises.access(filePath);
-        return true;
-    } catch  {
-        return false;
-    }
-};
-const readJson = async (filePath)=>JSON.parse(await promises.readFile(filePath, 'utf-8'));
-const verifyCloudflareOutput = async (options)=>{
-    const outputDirectory = node_path.resolve(options.outputDirectory);
-    const issues = [];
-    const outputPlan = createCloudflareOutputPlan(outputDirectory);
-    for (const relativePath of outputPlan.requiredFiles){
-        const filePath = node_path.join(outputDirectory, relativePath);
-        if (!await pathExists(filePath)) addIssue(issues, {
-            code: 'missing-file',
-            message: `Cloudflare output is missing ${relativePath}.`,
-            path: filePath
-        });
-    }
-    const manifestPath = outputPlan.paths.workerManifest;
-    const wranglerPath = outputPlan.paths.wranglerConfig;
-    const packagePath = outputPlan.paths.outputPackage;
-    const workerPackagePath = outputPlan.paths.workerPackage;
-    const manifest = await pathExists(manifestPath) ? await readJson(manifestPath) : void 0;
-    const wrangler = await pathExists(wranglerPath) ? await readJson(wranglerPath) : void 0;
-    const outputPackage = await pathExists(packagePath) ? await readJson(packagePath) : void 0;
-    const workerPackage = await pathExists(workerPackagePath) ? await readJson(workerPackagePath) : void 0;
-    if (manifest) {
-        verifyManifestShape(issues, manifest, manifestPath);
-        verifyDeliveryUnitIdentity(issues, manifest, manifestPath, options.deliveryUnit);
-        const workerReferences = getWorkerBundleReferences(manifest);
-        const providedWorkerPackages = new Set(workerPackage?.dependencies && 'object' == typeof workerPackage.dependencies ? Object.keys(workerPackage.dependencies) : []);
-        if (workerReferences.length > 0 && !await pathExists(workerPackagePath)) addIssue(issues, {
-            code: 'missing-file',
-            message: 'Cloudflare output is missing worker/package.json for referenced worker bundles.',
-            path: workerPackagePath
-        });
-        if (manifest.bff?.runtimeFramework === 'effect' && !getEffectBffWorker(manifest)) addIssue(issues, {
-            code: 'missing-worker-bundle',
-            message: 'Cloudflare Effect BFF manifest points to a missing worker bundle.'
-        });
-        for (const workerReference of workerReferences){
-            const resolvedWorker = resolveWorkerBundleReference(issues, outputDirectory, workerReference, manifestPath);
-            if (!resolvedWorker) continue;
-            const workerExists = await pathExists(resolvedWorker.path);
-            if (!workerExists) addIssue(issues, {
-                code: 'missing-worker-bundle',
-                message: missingWorkerBundleMessage(workerReference),
-                path: resolvedWorker.path
-            });
-            if (workerExists) {
-                const workerSource = await promises.readFile(resolvedWorker.path, 'utf-8');
-                await verifyWorkerBundleReferences(issues, resolvedWorker, workerSource, {
-                    providedPackages: providedWorkerPackages,
-                    workerRoot: outputPlan.paths.workerBundle
-                });
-                if ('effect-bff' === resolvedWorker.kind && (workerSource.includes(';entityKind;') || workerSource.includes(';entityKind,entityKind;'))) addIssue(issues, {
-                    code: 'invalid-worker-bundle',
-                    message: 'Cloudflare Effect BFF worker bundle contains invalid Drizzle entityKind marker references.',
-                    path: resolvedWorker.path
-                });
-            }
-        }
-    }
-    if (wrangler) {
-        assertEqual(issues, wrangler.main, outputPlan.wrangler.main, {
-            code: 'invalid-wrangler',
-            message: `wrangler.json main must be ${outputPlan.wrangler.main}.`,
-            path: wranglerPath
-        });
-        assertEqual(issues, wrangler.assets?.binding, outputPlan.wrangler.assets.binding, {
-            code: 'invalid-wrangler',
-            message: 'wrangler.json assets.binding must be ASSETS.',
-            path: wranglerPath
-        });
-        assertEqual(issues, wrangler.assets?.directory, outputPlan.wrangler.assets.directory, {
-            code: 'invalid-wrangler',
-            message: 'wrangler.json assets.directory must be ./public.',
-            path: wranglerPath
-        });
-        assertEqual(issues, wrangler.assets?.run_worker_first, outputPlan.wrangler.assets.run_worker_first, {
-            code: 'invalid-wrangler',
-            message: 'wrangler.json assets.run_worker_first must be true.',
-            path: wranglerPath
-        });
-        for (const flag of outputPlan.wrangler.requiredCompatibilityFlags)assertFlag(issues, wrangler.compatibility_flags, flag, {
-            code: 'invalid-wrangler',
-            message: `wrangler.json compatibility_flags must include ${flag}.`,
-            path: wranglerPath
-        });
-    }
-    if (outputPackage) assertEqual(issues, outputPackage.type, outputPlan.packages.output.type, {
-        code: 'invalid-package',
-        message: '.output/package.json must declare type module.',
-        path: packagePath
-    });
-    if (workerPackage) assertEqual(issues, workerPackage.type, outputPlan.packages.worker.type, {
-        code: 'invalid-package',
-        message: '.output/worker/package.json must declare type commonjs.',
-        path: workerPackagePath
-    });
-    for (const leakedPath of outputPlan.publicLeakDirectories){
-        const publicPath = node_path.join(outputPlan.paths.publicAssets, leakedPath);
-        if (await pathExists(publicPath)) addIssue(issues, {
-            code: 'public-output-leak',
-            message: `Framework-owned ${leakedPath} output leaked into public assets.`,
-            path: publicPath
-        });
-    }
-    if (false !== options.importWorker && await pathExists(outputPlan.paths.workerEntry)) await verifyWorkerImport(issues, outputPlan.paths.workerEntry, manifest);
-    return {
-        ok: 0 === issues.length,
-        issues
-    };
-};
-const assertCloudflareOutput = async (options)=>{
-    const result = await verifyCloudflareOutput(options);
-    if (!result.ok) throw new Error([
-        'Cloudflare output verification failed:',
-        ...result.issues.map((issue)=>`- ${issue.code}: ${issue.message}${issue.path ? ` (${issue.path})` : ''}`)
-    ].join('\n'));
-};
-export { verifyCloudflareOutputMutationPolicy } from "./mutation-policy.mjs";
-export { assertCloudflareOutput, verifyCloudflareOutput };
+export * from "@modern-js/app-tools-extensions/cloudflare-output-verifier";

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

@@ -1,78 +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';
-}
-
+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 [];
-  }
+    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;
+    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);
-      }
+    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
+        try {
+            requestHandler = await initServer();
+        } catch (error) {
+            console.error('Error creating server:', error);
+            process.exit(1);
+        }
     })();
-  }
-  await handlerCreationPromise;
-  return requestHandler;
+    await handlerCreationPromise;
+    return requestHandler;
 }
-
 createHandler();
-
-const handler = async (request, context) => {
-  if (!requestHandler) {
-    await createHandler();
-  }
-  return requestHandler(request, context);
+const handler = async (request, context)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(request, context);
 };
-
 module.exports.default = handler;

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

@@ -2,80 +2,58 @@ 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';
-}
-
+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 [];
-  }
+    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;
+    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);
-      }
+    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
+        try {
+            requestHandler = await initServer();
+        } catch (error) {
+            console.error('Error creating server:', error);
+            process.exit(1);
+        }
     })();
-  }
-  await handlerCreationPromise;
-  return requestHandler;
+    await handlerCreationPromise;
+    return requestHandler;
 }
-
 createHandler();
-
-const handler = async (request, context) => {
-  if (!requestHandler) {
-    await createHandler();
-  }
-  return requestHandler(request, context);
+const handler = async (request, context)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(request, context);
 };
-
 export default handler;