@modern-js/app-tools 3.1.0 → 3.1.2

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

@@ -1,5 +1,4 @@
 import { isPromise } from "node:util/types";
-import { extname, resolve } from "path";
 import { createDebugger, fs, getArgv, getMeta, isApiOnly, isDevCommand, minimist } from "@modern-js/utils";
 import { createBuilderGenerator } from "../../builder/index.mjs";
 import { initialNormalizedConfig } from "../../config/index.mjs";
@@ -8,6 +7,7 @@ import { getSelectedEntries } from "../../utils/getSelectedEntries.mjs";
 import { printInstructions } from "../../utils/printInstructions.mjs";
 import { generateRoutes } from "../../utils/routes.mjs";
 import { checkIsBuildCommands, checkIsServeCommand } from "./utils.mjs";
+import * as __rspack_external_path from "path";
 const debug = createDebugger('plugin-analyze');
 const analyze = ()=>({
         name: '@modern-js/plugin-analyze',
@@ -74,7 +74,7 @@ const analyze = ()=>({
                 };
                 api.updateAppContext(appContext);
                 nestedRouteEntries = entrypoints.map((point)=>point.nestedRoutesEntry).filter(Boolean);
-                pagesDir = entrypoints.map((point)=>point.entry).filter((entry)=>entry && !extname(entry)).concat(nestedRouteEntries);
+                pagesDir = entrypoints.map((point)=>point.entry).filter((entry)=>entry && !__rspack_external_path.extname(entry)).concat(nestedRouteEntries);
                 const meta = getMeta(api.getAppContext().metaName);
                 const possibleNames = [
                     `${meta}.routes.ts`,
@@ -88,7 +88,7 @@ const analyze = ()=>({
                     const { absoluteEntryDir } = entrypoint;
                     if (!absoluteEntryDir) return;
                     for (const filename of possibleNames){
-                        const filePath = resolve(absoluteEntryDir, filename);
+                        const filePath = __rspack_external_path.resolve(absoluteEntryDir, filename);
                         if (await fs.pathExists(filePath)) {
                             const stats = await fs.stat(filePath);
                             if (stats.isFile()) routesConfigFiles.push(filePath);
@@ -174,7 +174,7 @@ const analyze = ()=>({
                     const getFlattenedPlugins = async (pluginOptions)=>{
                         let plugins = pluginOptions;
                         do plugins = (await Promise.all(plugins)).flat(1 / 0);
-                        while (plugins.some((v)=>isPromise(v)));
+                        while (plugins.some((v)=>isPromise(v)))
                         return plugins;
                     };
                     if (resolvedConfig.builderPlugins) {
@@ -200,4 +200,4 @@ const analyze = ()=>({
             });
         }
     });
-export { analyze as default };
+export default analyze;

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

@@ -1,8 +1,8 @@
 import fs from "fs";
 import { parse } from "@babel/parser";
 import traverse from "@babel/traverse";
-import { isArrowFunctionExpression, isFunctionDeclaration, isFunctionExpression } from "@babel/types";
-const isFunction = (node)=>isFunctionDeclaration(node) || isFunctionExpression(node) || isArrowFunctionExpression(node);
+import * as __rspack_external__babel_types_69e65b52 from "@babel/types";
+const isFunction = (node)=>__rspack_external__babel_types_69e65b52.isFunctionDeclaration(node) || __rspack_external__babel_types_69e65b52.isFunctionExpression(node) || __rspack_external__babel_types_69e65b52.isArrowFunctionExpression(node);
 const isDefaultExportFunction = (file)=>{
     if (!file || !fs.existsSync(file)) return false;
     const ast = parse(fs.readFileSync(file, 'utf8'), {

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

@@ -40,4 +40,4 @@ const deploy = ()=>({
             });
         }
     });
-export { deploy as default };
+export default deploy;

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

@@ -54,4 +54,4 @@ const handler = async (request, context)=>{
     if (!requestHandler) await createHandler();
     return requestHandler(request, context);
 };
-exports.handler = handler;
+module.exports.default = handler;

package/dist/esm/plugins/deploy/utils/generator.mjs

@@ -4,10 +4,11 @@ import { merge } from "@modern-js/utils/lodash";
 import { normalizePath } from "./index.mjs";
 const serverAppContextTemplate = (appContext)=>{
     const { appDirectory, sharedDirectory, apiDirectory, lambdaDirectory, metaName, bffRuntimeFramework } = appContext;
+    const getRelativePathTemplate = (targetDirectory)=>`path.join(__dirname, ${JSON.stringify(normalizePath(node_path.relative(appDirectory, targetDirectory)))})`;
     return {
-        sharedDirectory: `path.join(__dirname, "${normalizePath(node_path.relative(appDirectory, sharedDirectory))}")`,
-        apiDirectory: `path.join(__dirname, "${normalizePath(node_path.relative(appDirectory, apiDirectory))}")`,
-        lambdaDirectory: `path.join(__dirname, "${normalizePath(node_path.relative(appDirectory, lambdaDirectory))}")`,
+        sharedDirectory: getRelativePathTemplate(sharedDirectory),
+        apiDirectory: getRelativePathTemplate(apiDirectory),
+        lambdaDirectory: getRelativePathTemplate(lambdaDirectory),
         metaName,
         bffRuntimeFramework: bffRuntimeFramework || 'hono'
     };

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

@@ -56,4 +56,4 @@ async function getServerPort(config) {
     if (isDev() && isDevCommand()) return getPort(Number(process.env.PORT) || prodPort);
     return prodPort;
 }
-export { initialize as default };
+export default initialize;

package/dist/esm/plugins/serverBuild.mjs

@@ -43,4 +43,4 @@ const serverBuild = ()=>({
             });
         }
     });
-export { serverBuild as default };
+export default serverBuild;

package/dist/esm/plugins/serverRuntime.mjs

@@ -12,4 +12,4 @@ const serverRuntime = ()=>({
                 }));
         }
     });
-export { serverRuntime as default };
+export default serverRuntime;

package/dist/esm/utils/config.mjs

@@ -1,8 +1,8 @@
-import { join } from "path";
 import { OUTPUT_CONFIG_FILE, ensureAbsolutePath, fs } from "@modern-js/utils";
 import { stringify } from "flatted";
+import * as __rspack_external_path from "path";
 const emitResolvedConfig = async (appDirectory, resolvedConfig)=>{
-    const outputPath = ensureAbsolutePath(appDirectory, join(resolvedConfig.output.distPath?.root || './dist', OUTPUT_CONFIG_FILE));
+    const outputPath = ensureAbsolutePath(appDirectory, __rspack_external_path.join(resolvedConfig.output.distPath?.root || './dist', OUTPUT_CONFIG_FILE));
     const output = stringify(resolvedConfig);
     await fs.writeFile(outputPath, output, {
         encoding: 'utf-8'

package/dist/esm/utils/register.mjs

@@ -1,11 +1,21 @@
 import node_path from "node:path";
 import { fs, getAliasConfig, isDepExists, loadFromProject, readTsConfigByFile } from "@modern-js/utils";
-const setupTsRuntime = async (appDir, distDir, alias)=>{
+const resolveTsRuntimeRegisterMode = (hasTsNode)=>{
+    const hasNativeTypeScriptSupport = process.features?.typescript;
+    const nodeMajorVersion = Number(process.versions.node.split('.')[0]);
+    const supportsNativeTypeScript = void 0 === hasNativeTypeScriptSupport ? nodeMajorVersion >= 22 : false !== hasNativeTypeScriptSupport;
+    if (supportsNativeTypeScript) return 'node-loader';
+    if (hasTsNode) return 'ts-node';
+    return 'unsupported';
+};
+const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
     const TS_CONFIG_FILENAME = "tsconfig.json";
     const tsconfigPath = node_path.resolve(appDir, TS_CONFIG_FILENAME);
     const isTsProject = await fs.pathExists(tsconfigPath);
     const hasTsNode = isDepExists(appDir, 'ts-node');
-    if (!isTsProject || !hasTsNode) return;
+    if (!isTsProject) return;
+    const preferredRegisterMode = resolveTsRuntimeRegisterMode(hasTsNode);
+    const registerMode = options.preferTsNodeForServerRuntime && hasTsNode ? 'ts-node' : preferredRegisterMode;
     const aliasConfig = getAliasConfig(alias, {
         appDirectory: appDir,
         tsconfigPath
@@ -30,24 +40,42 @@ const setupTsRuntime = async (appDir, distDir, alias)=>{
             [`${key}`]: tsPath
         };
     }, {});
-    const tsConfig = readTsConfigByFile(tsconfigPath);
-    const tsNode = await loadFromProject('ts-node', appDir);
-    const tsNodeOptions = tsConfig['ts-node'];
-    tsNode.register({
-        project: tsconfigPath,
-        scope: true,
-        files: true,
-        transpileOnly: true,
-        ignore: [
-            '(?:^|/)node_modules/',
-            `(?:^|/)${node_path.relative(appDir, distDir)}/`
-        ],
-        ...tsNodeOptions
-    });
+    if ('unsupported' === registerMode) return;
+    if ('ts-node' === registerMode) {
+        if ('module' === options.moduleType) {
+            const { registerModuleHooks } = await import("../esm/register-esm.mjs");
+            await registerModuleHooks({
+                appDir,
+                distDir,
+                alias: alias || {}
+            });
+        }
+        const tsConfig = readTsConfigByFile(tsconfigPath);
+        const tsNode = await loadFromProject('ts-node', appDir);
+        const tsNodeOptions = tsConfig['ts-node'];
+        tsNode.register({
+            project: tsconfigPath,
+            scope: true,
+            files: true,
+            transpileOnly: true,
+            ignore: [
+                '(?:^|/)node_modules/',
+                `(?:^|/)${node_path.relative(appDir, distDir)}/`
+            ],
+            ...tsNodeOptions
+        });
+    } else if ('node-loader' === registerMode) {
+        const { registerPathsLoader } = await import("../esm/register-esm.mjs");
+        await registerPathsLoader({
+            appDir,
+            baseUrl: absoluteBaseUrl || './',
+            paths: tsPaths
+        });
+    }
     const { register } = await import("@modern-js/utils/tsconfig-paths");
     register({
         baseUrl: absoluteBaseUrl || './',
         paths: tsPaths
     });
 };
-export { setupTsRuntime };
+export { resolveTsRuntimeRegisterMode, setupTsRuntime };

package/dist/esm-node/builder/generator/createCopyPattern.mjs

@@ -8,7 +8,7 @@ const info = (file)=>({
 function createPublicPattern(appContext, config, chain) {
     const { publicDir } = createCopyInfo(appContext, config);
     return {
-        info,
+        info: info,
         from: '**/*',
         to: 'public',
         context: publicDir,

package/dist/esm-node/builder/index.mjs

@@ -1,8 +1,8 @@
 import "node:module";
-import { parseRspackConfig } from "@modern-js/builder";
-import { builderPluginAdapterBasic, builderPluginAdapterHooks } from "./shared/builderPlugins/index.mjs";
 async function createBuilderGenerator() {
     const { createRspackBuilderForModern } = await import("./builder-rspack/index.mjs");
     return createRspackBuilderForModern;
 }
-export { builderPluginAdapterBasic, builderPluginAdapterHooks, createBuilderGenerator, parseRspackConfig };
+export { parseRspackConfig } from "@modern-js/builder";
+export { builderPluginAdapterBasic, builderPluginAdapterHooks } from "./shared/builderPlugins/index.mjs";
+export { createBuilderGenerator };

package/dist/esm-node/builder/shared/builderPlugins/adapterBasic.mjs

@@ -1,8 +1,8 @@
 import "node:module";
-import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
-import { dirname as __rspack_dirname } from "node:path";
 import node_path from "node:path";
 import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/builder";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
 var adapterBasic_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 const builderPluginAdapterBasic = (options)=>({
         name: 'builder-plugin-adapter-modern-basic',

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

@@ -1,11 +1,11 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-import { resolve, sep } from "path";
 import { SERVICE_WORKER_ENVIRONMENT_NAME, isHtmlDisabled } from "@modern-js/builder";
 import { fs, isUseRsc, isUseSSRBundle } from "@modern-js/utils";
 import { mergeRsbuildConfig } from "@rsbuild/core";
 import { getServerCombinedModuleFile } from "../../../plugins/analyze/utils.mjs";
 import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins/index.mjs";
+import * as __rspack_external_path from "path";
 const builderPluginAdapterSSR = (options)=>({
         name: 'builder-plugin-adapter-modern-ssr',
         setup (api) {
@@ -112,7 +112,7 @@ function applySSRDataLoader(chain, options) {
     const { normalizedConfig, appContext } = options;
     const { appDirectory } = appContext;
     const { entriesDir = './src' } = normalizedConfig.source;
-    const absolutePath = resolve(appDirectory, entriesDir).split(sep).join('(\\\\|/)');
+    const absolutePath = __rspack_external_path.resolve(appDirectory, entriesDir).split(__rspack_external_path.sep).join('(\\\\|/)');
     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();
 }

package/dist/esm-node/builder/shared/loaders/serverModuleLoader.mjs

@@ -3,4 +3,4 @@ function loader() {
     return "module.exports = {}";
 }
 const serverModuleLoader = loader;
-export { serverModuleLoader as default };
+export default serverModuleLoader;

package/dist/esm-node/commands/build.mjs

@@ -33,15 +33,9 @@ const build = async (api, options)=>{
     const hooks = api.getHooks();
     const combinedAlias = [].concat(resolvedConfig?.resolve?.alias ?? []).concat(resolvedConfig?.source?.alias ?? []);
     await loadServerPlugins(api, appContext.appDirectory, appContext.metaName);
-    if (appContext.moduleType && 'module' === appContext.moduleType) {
-        const { registerModuleHooks } = await import("../esm/register-esm.mjs");
-        await registerModuleHooks({
-            appDir: appContext.appDirectory,
-            distDir: appContext.distDirectory,
-            alias: {}
-        });
-    }
-    await setupTsRuntime(appContext.appDirectory, appContext.distDirectory, combinedAlias);
+    await setupTsRuntime(appContext.appDirectory, appContext.distDirectory, combinedAlias, {
+        moduleType: appContext.moduleType
+    });
     const { apiOnly } = appContext;
     if (apiOnly) {
         await hooks.onBeforeBuild.call({

package/dist/esm-node/commands/dev.mjs

@@ -14,15 +14,10 @@ const dev = async (api, options, devServerOptions)=>{
     const appContext = api.getAppContext();
     const hooks = api.getHooks();
     const combinedAlias = [].concat(normalizedConfig?.resolve?.alias ?? []).concat(normalizedConfig?.source?.alias ?? []);
-    if (appContext.moduleType && 'module' === appContext.moduleType) {
-        const { registerModuleHooks } = await import("../esm/register-esm.mjs");
-        await registerModuleHooks({
-            appDir: appContext.appDirectory,
-            distDir: appContext.distDirectory,
-            alias: {}
-        });
-    }
-    await setupTsRuntime(appContext.appDirectory, appContext.distDirectory, combinedAlias);
+    await setupTsRuntime(appContext.appDirectory, appContext.distDirectory, combinedAlias, {
+        moduleType: appContext.moduleType,
+        preferTsNodeForServerRuntime: true
+    });
     const { appDirectory, port, apiOnly, metaName, serverRoutes } = appContext;
     const meta = getMeta(metaName);
     const serverConfigPath = node_path.resolve(appDirectory, SERVER_DIR, `${meta}.server`);

package/dist/esm-node/esm/register-esm.mjs

@@ -1,20 +1,11 @@
 import "node:module";
 import node_path from "node:path";
 import { fs } from "@modern-js/utils";
-const checkDepExist = async (dep)=>{
-    try {
-        await import(dep);
-        return true;
-    } catch  {
-        return false;
-    }
-};
 const registerModuleHooks = async ({ appDir, distDir, alias })=>{
     const TS_CONFIG_FILENAME = "tsconfig.json";
     const tsconfigPath = node_path.resolve(appDir, TS_CONFIG_FILENAME);
     const hasTsconfig = await fs.pathExists(tsconfigPath);
-    const hasTsNode = await checkDepExist('ts-node');
-    if (!hasTsconfig || !hasTsNode) return;
+    if (!hasTsconfig) return;
     const { register } = await import("node:module");
     process.env.TS_NODE_TRANSPILE_ONLY = true;
     process.env.TS_NODE_PROJECT = tsconfigPath;
@@ -30,4 +21,14 @@ const registerModuleHooks = async ({ appDir, distDir, alias })=>{
         }
     });
 };
-export { registerModuleHooks };
+const registerPathsLoader = async ({ appDir, baseUrl, paths })=>{
+    const { register } = await import("node:module");
+    register('./ts-paths-loader.mjs', import.meta.url, {
+        data: {
+            appDir,
+            baseUrl,
+            paths
+        }
+    });
+};
+export { registerModuleHooks, registerPathsLoader };

package/dist/esm-node/esm/ts-paths-loader.mjs

@@ -0,0 +1,59 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { fileURLToPath, pathToFileURL } from "url";
+import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
+let matchPath;
+let appDir;
+const resolvePathWithExtensions = (matchedPath)=>{
+    if (node_path.extname(matchedPath)) return matchedPath;
+    const fileCandidates = [
+        matchedPath,
+        `${matchedPath}.ts`,
+        `${matchedPath}.tsx`,
+        `${matchedPath}.mts`,
+        `${matchedPath}.cts`,
+        `${matchedPath}.js`,
+        `${matchedPath}.mjs`,
+        `${matchedPath}.cjs`
+    ];
+    for (const candidate of fileCandidates)if (node_fs.existsSync(candidate) && node_fs.statSync(candidate).isFile()) return candidate;
+    const indexCandidates = [
+        node_path.join(matchedPath, 'index.ts'),
+        node_path.join(matchedPath, 'index.tsx'),
+        node_path.join(matchedPath, 'index.mts'),
+        node_path.join(matchedPath, 'index.cts'),
+        node_path.join(matchedPath, 'index.js'),
+        node_path.join(matchedPath, 'index.mjs'),
+        node_path.join(matchedPath, 'index.cjs')
+    ];
+    for (const candidate of indexCandidates)if (node_fs.existsSync(candidate) && node_fs.statSync(candidate).isFile()) return candidate;
+    return matchedPath;
+};
+async function initialize({ appDir: currentAppDir, baseUrl, paths }) {
+    appDir = node_path.resolve(currentAppDir);
+    matchPath = createMatchPath(baseUrl || './', paths || {});
+}
+function resolve(specifier, context, defaultResolve) {
+    const parentPath = context.parentURL ? node_path.dirname(fileURLToPath(context.parentURL)) : process.cwd();
+    const relativeFromApp = appDir ? node_path.relative(appDir, parentPath) : '';
+    const isAppFile = appDir && (parentPath === appDir || relativeFromApp && !relativeFromApp.startsWith('..') && !node_path.isAbsolute(relativeFromApp));
+    if ((specifier.startsWith('./') || specifier.startsWith('../')) && !node_path.extname(specifier) && isAppFile) {
+        const resolvedPath = resolvePathWithExtensions(node_path.resolve(parentPath, specifier));
+        if (resolvedPath && node_fs.existsSync(resolvedPath)) return defaultResolve(pathToFileURL(resolvedPath).href, context, defaultResolve);
+    }
+    if (!matchPath) return defaultResolve(specifier, context, defaultResolve);
+    const match = matchPath(specifier, void 0, void 0, [
+        '.ts',
+        '.tsx',
+        '.mts',
+        '.cts',
+        '.js',
+        '.mjs',
+        '.cjs'
+    ]);
+    if (!match) return defaultResolve(specifier, context, defaultResolve);
+    const resolvedPath = resolvePathWithExtensions(match);
+    return defaultResolve(pathToFileURL(resolvedPath).href, context, defaultResolve);
+}
+export { initialize, resolve };

package/dist/esm-node/index.mjs

@@ -17,11 +17,6 @@ import serverRuntime from "./plugins/serverRuntime.mjs";
 import { generateWatchFiles } from "./utils/generateWatchFiles.mjs";
 import { initAppContext } from "./utils/initAppContext.mjs";
 import { restart } from "./utils/restart.mjs";
-import { defineConfig } from "./defineConfig.mjs";
-import { dev } from "./commands/dev.mjs";
-import { serve } from "./commands/serve.mjs";
-import { resolveModernRsbuildConfig } from "./rsbuild.mjs";
-import { mergeConfig } from "@modern-js/plugin/cli";
 export * from "./defineConfig.mjs";
 export * from "./types/index.mjs";
 const appTools = ()=>({
@@ -122,4 +117,10 @@ const appTools = ()=>({
         }
     });
 const src = appTools;
-export { appTools, src as default, defineConfig, dev, generateWatchFiles, initAppContext, mergeConfig, resolveModernRsbuildConfig, serve };
+export { defineConfig } from "./defineConfig.mjs";
+export { dev } from "./commands/dev.mjs";
+export { serve } from "./commands/serve.mjs";
+export { resolveModernRsbuildConfig } from "./rsbuild.mjs";
+export { mergeConfig } from "@modern-js/plugin/cli";
+export default src;
+export { appTools, generateWatchFiles, initAppContext };

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

@@ -2,7 +2,7 @@ import "node:module";
 import path from "path";
 import { findExists, fs } from "@modern-js/utils";
 import { HTML_PARTIALS_EXTENSIONS, HTML_PARTIALS_FOLDER } from "./constants.mjs";
-import { html } from "./templates.mjs";
+import * as __rspack_external__templates_mjs_4da4c6c8 from "./templates.mjs";
 const findPartials = (dir, entryName, position)=>{
     if (fs.existsSync(dir)) {
         const base = findExists(HTML_PARTIALS_EXTENSIONS.map((ext)=>path.resolve(dir, `${position}${ext}`)));
@@ -71,7 +71,7 @@ const getHtmlTemplate = async (entrypoints, hooks, { appContext, config })=>{
                 partials: getModifyHtmlPartials(partials)
             });
             const templatePath = path.resolve(internalDirectory, entryName, 'index.html');
-            fs.outputFileSync(templatePath, html(partials), 'utf8');
+            fs.outputFileSync(templatePath, __rspack_external__templates_mjs_4da4c6c8.html(partials), 'utf8');
             htmlTemplates[entryName] = templatePath.replace(/\\/g, '/');
             partialsByEntrypoint[entryName] = partials;
             const bottomTemplate = findPartials(htmlDir, name, "bottom");

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

@@ -1,6 +1,5 @@
 import "node:module";
 import { isPromise } from "node:util/types";
-import { extname, resolve } from "path";
 import { createDebugger, fs, getArgv, getMeta, isApiOnly, isDevCommand, minimist } from "@modern-js/utils";
 import { createBuilderGenerator } from "../../builder/index.mjs";
 import { initialNormalizedConfig } from "../../config/index.mjs";
@@ -9,6 +8,7 @@ import { getSelectedEntries } from "../../utils/getSelectedEntries.mjs";
 import { printInstructions } from "../../utils/printInstructions.mjs";
 import { generateRoutes } from "../../utils/routes.mjs";
 import { checkIsBuildCommands, checkIsServeCommand } from "./utils.mjs";
+import * as __rspack_external_path from "path";
 const debug = createDebugger('plugin-analyze');
 const analyze = ()=>({
         name: '@modern-js/plugin-analyze',
@@ -75,7 +75,7 @@ const analyze = ()=>({
                 };
                 api.updateAppContext(appContext);
                 nestedRouteEntries = entrypoints.map((point)=>point.nestedRoutesEntry).filter(Boolean);
-                pagesDir = entrypoints.map((point)=>point.entry).filter((entry)=>entry && !extname(entry)).concat(nestedRouteEntries);
+                pagesDir = entrypoints.map((point)=>point.entry).filter((entry)=>entry && !__rspack_external_path.extname(entry)).concat(nestedRouteEntries);
                 const meta = getMeta(api.getAppContext().metaName);
                 const possibleNames = [
                     `${meta}.routes.ts`,
@@ -89,7 +89,7 @@ const analyze = ()=>({
                     const { absoluteEntryDir } = entrypoint;
                     if (!absoluteEntryDir) return;
                     for (const filename of possibleNames){
-                        const filePath = resolve(absoluteEntryDir, filename);
+                        const filePath = __rspack_external_path.resolve(absoluteEntryDir, filename);
                         if (await fs.pathExists(filePath)) {
                             const stats = await fs.stat(filePath);
                             if (stats.isFile()) routesConfigFiles.push(filePath);
@@ -201,4 +201,4 @@ const analyze = ()=>({
             });
         }
     });
-export { analyze as default };
+export default analyze;

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

@@ -2,8 +2,8 @@ import "node:module";
 import fs from "fs";
 import { parse } from "@babel/parser";
 import traverse from "@babel/traverse";
-import { isArrowFunctionExpression, isFunctionDeclaration, isFunctionExpression } from "@babel/types";
-const isFunction = (node)=>isFunctionDeclaration(node) || isFunctionExpression(node) || isArrowFunctionExpression(node);
+import * as __rspack_external__babel_types_69e65b52 from "@babel/types";
+const isFunction = (node)=>__rspack_external__babel_types_69e65b52.isFunctionDeclaration(node) || __rspack_external__babel_types_69e65b52.isFunctionExpression(node) || __rspack_external__babel_types_69e65b52.isArrowFunctionExpression(node);
 const isDefaultExportFunction = (file)=>{
     if (!file || !fs.existsSync(file)) return false;
     const ast = parse(fs.readFileSync(file, 'utf8'), {

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

@@ -41,4 +41,4 @@ const deploy = ()=>({
             });
         }
     });
-export { deploy as default };
+export default deploy;

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

@@ -54,4 +54,4 @@ const handler = async (request, context)=>{
     if (!requestHandler) await createHandler();
     return requestHandler(request, context);
 };
-exports.handler = handler;
+module.exports.default = handler;

package/dist/esm-node/plugins/deploy/utils/generator.mjs

@@ -5,10 +5,11 @@ import { merge } from "@modern-js/utils/lodash";
 import { normalizePath } from "./index.mjs";
 const serverAppContextTemplate = (appContext)=>{
     const { appDirectory, sharedDirectory, apiDirectory, lambdaDirectory, metaName, bffRuntimeFramework } = appContext;
+    const getRelativePathTemplate = (targetDirectory)=>`path.join(__dirname, ${JSON.stringify(normalizePath(node_path.relative(appDirectory, targetDirectory)))})`;
     return {
-        sharedDirectory: `path.join(__dirname, "${normalizePath(node_path.relative(appDirectory, sharedDirectory))}")`,
-        apiDirectory: `path.join(__dirname, "${normalizePath(node_path.relative(appDirectory, apiDirectory))}")`,
-        lambdaDirectory: `path.join(__dirname, "${normalizePath(node_path.relative(appDirectory, lambdaDirectory))}")`,
+        sharedDirectory: getRelativePathTemplate(sharedDirectory),
+        apiDirectory: getRelativePathTemplate(apiDirectory),
+        lambdaDirectory: getRelativePathTemplate(lambdaDirectory),
         metaName,
         bffRuntimeFramework: bffRuntimeFramework || 'hono'
     };

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

@@ -1,9 +1,9 @@
 import "node:module";
-import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
-import { dirname as __rspack_dirname } from "node:path";
 import { pathToFileURL } from "node:url";
 import path from "path";
 import { ROUTE_SPEC_FILE, SERVER_DIR, fs, getMeta } from "@modern-js/utils";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
 var utils_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 const normalizePath = (filePath)=>filePath.replace(/\\/g, '/');
 const getProjectUsage = (appDirectory, distDirectory, metaName)=>{

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

@@ -57,4 +57,4 @@ async function getServerPort(config) {
     if (isDev() && isDevCommand()) return getPort(Number(process.env.PORT) || prodPort);
     return prodPort;
 }
-export { initialize as default };
+export default initialize;

package/dist/esm-node/plugins/serverBuild.mjs

@@ -44,4 +44,4 @@ const serverBuild = ()=>({
             });
         }
     });
-export { serverBuild as default };
+export default serverBuild;

package/dist/esm-node/plugins/serverRuntime.mjs

@@ -13,4 +13,4 @@ const serverRuntime = ()=>({
                 }));
         }
     });
-export { serverRuntime as default };
+export default serverRuntime;

package/dist/esm-node/utils/config.mjs

@@ -1,9 +1,9 @@
 import "node:module";
-import { join } from "path";
 import { OUTPUT_CONFIG_FILE, ensureAbsolutePath, fs } from "@modern-js/utils";
 import { stringify } from "flatted";
+import * as __rspack_external_path from "path";
 const emitResolvedConfig = async (appDirectory, resolvedConfig)=>{
-    const outputPath = ensureAbsolutePath(appDirectory, join(resolvedConfig.output.distPath?.root || './dist', OUTPUT_CONFIG_FILE));
+    const outputPath = ensureAbsolutePath(appDirectory, __rspack_external_path.join(resolvedConfig.output.distPath?.root || './dist', OUTPUT_CONFIG_FILE));
     const output = stringify(resolvedConfig);
     await fs.writeFile(outputPath, output, {
         encoding: 'utf-8'