@modern-js/app-tools 3.1.0 → 3.1.2

package/dist/cjs/commands/build.js

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

package/dist/cjs/commands/dev.js

@@ -51,15 +51,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.js");
-        await registerModuleHooks({
-            appDir: appContext.appDirectory,
-            distDir: appContext.distDirectory,
-            alias: {}
-        });
-    }
-    await (0, register_js_namespaceObject.setupTsRuntime)(appContext.appDirectory, appContext.distDirectory, combinedAlias);
+    await (0, register_js_namespaceObject.setupTsRuntime)(appContext.appDirectory, appContext.distDirectory, combinedAlias, {
+        moduleType: appContext.moduleType,
+        preferTsNodeForServerRuntime: true
+    });
     const { appDirectory, port, apiOnly, metaName, serverRoutes } = appContext;
     const meta = (0, utils_namespaceObject.getMeta)(metaName);
     const serverConfigPath = external_node_path_default().resolve(appDirectory, utils_namespaceObject.SERVER_DIR, `${meta}.server`);

package/dist/cjs/esm/register-esm.js

@@ -27,24 +27,16 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    registerModuleHooks: ()=>registerModuleHooks
+    registerModuleHooks: ()=>registerModuleHooks,
+    registerPathsLoader: ()=>registerPathsLoader
 });
 const external_node_path_namespaceObject = require("node:path");
 const utils_namespaceObject = require("@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 = external_node_path_namespaceObject.resolve(appDir, TS_CONFIG_FILENAME);
     const hasTsconfig = await utils_namespaceObject.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;
@@ -60,9 +52,21 @@ const registerModuleHooks = async ({ appDir, distDir, alias })=>{
         }
     });
 };
+const registerPathsLoader = async ({ appDir, baseUrl, paths })=>{
+    const { register } = await import("node:module");
+    register('./ts-paths-loader.mjs', __rslib_import_meta_url__, {
+        data: {
+            appDir,
+            baseUrl,
+            paths
+        }
+    });
+};
 exports.registerModuleHooks = __webpack_exports__.registerModuleHooks;
+exports.registerPathsLoader = __webpack_exports__.registerPathsLoader;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "registerModuleHooks"
+    "registerModuleHooks",
+    "registerPathsLoader"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

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

@@ -1,19 +1,10 @@
 import path from 'node:path';
 import { fs } from '@modern-js/utils';
-const checkDepExist = async (dep)=>{
-    try {
-        await import(dep);
-        return true;
-    } catch  {
-        return false;
-    }
-};
 export const registerModuleHooks = async ({ appDir, distDir, alias })=>{
     const TS_CONFIG_FILENAME = "tsconfig.json";
     const tsconfigPath = 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;
@@ -29,3 +20,13 @@ export const registerModuleHooks = async ({ appDir, distDir, alias })=>{
         }
     });
 };
+export const registerPathsLoader = async ({ appDir, baseUrl, paths })=>{
+    const { register } = await import('node:module');
+    register('./ts-paths-loader.mjs', import.meta.url, {
+        data: {
+            appDir,
+            baseUrl,
+            paths
+        }
+    });
+};

package/dist/cjs/esm/ts-paths-loader.js

@@ -0,0 +1,95 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    initialize: ()=>initialize,
+    resolve: ()=>resolve
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_url_namespaceObject = require("url");
+const tsconfig_paths_namespaceObject = require("@modern-js/utils/tsconfig-paths");
+let matchPath;
+let appDir;
+const resolvePathWithExtensions = (matchedPath)=>{
+    if (external_node_path_namespaceObject.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 (external_node_fs_namespaceObject.existsSync(candidate) && external_node_fs_namespaceObject.statSync(candidate).isFile()) return candidate;
+    const indexCandidates = [
+        external_node_path_namespaceObject.join(matchedPath, 'index.ts'),
+        external_node_path_namespaceObject.join(matchedPath, 'index.tsx'),
+        external_node_path_namespaceObject.join(matchedPath, 'index.mts'),
+        external_node_path_namespaceObject.join(matchedPath, 'index.cts'),
+        external_node_path_namespaceObject.join(matchedPath, 'index.js'),
+        external_node_path_namespaceObject.join(matchedPath, 'index.mjs'),
+        external_node_path_namespaceObject.join(matchedPath, 'index.cjs')
+    ];
+    for (const candidate of indexCandidates)if (external_node_fs_namespaceObject.existsSync(candidate) && external_node_fs_namespaceObject.statSync(candidate).isFile()) return candidate;
+    return matchedPath;
+};
+async function initialize({ appDir: currentAppDir, baseUrl, paths }) {
+    appDir = external_node_path_namespaceObject.resolve(currentAppDir);
+    matchPath = (0, tsconfig_paths_namespaceObject.createMatchPath)(baseUrl || './', paths || {});
+}
+function resolve(specifier, context, defaultResolve) {
+    const parentPath = context.parentURL ? external_node_path_namespaceObject.dirname((0, external_url_namespaceObject.fileURLToPath)(context.parentURL)) : process.cwd();
+    const relativeFromApp = appDir ? external_node_path_namespaceObject.relative(appDir, parentPath) : '';
+    const isAppFile = appDir && (parentPath === appDir || relativeFromApp && !relativeFromApp.startsWith('..') && !external_node_path_namespaceObject.isAbsolute(relativeFromApp));
+    if ((specifier.startsWith('./') || specifier.startsWith('../')) && !external_node_path_namespaceObject.extname(specifier) && isAppFile) {
+        const resolvedPath = resolvePathWithExtensions(external_node_path_namespaceObject.resolve(parentPath, specifier));
+        if (resolvedPath && external_node_fs_namespaceObject.existsSync(resolvedPath)) return defaultResolve((0, external_url_namespaceObject.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((0, external_url_namespaceObject.pathToFileURL)(resolvedPath).href, context, defaultResolve);
+}
+exports.initialize = __webpack_exports__.initialize;
+exports.resolve = __webpack_exports__.resolve;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initialize",
+    "resolve"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/dist/cjs/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/cjs/plugins/deploy/utils/generator.js

@@ -46,10 +46,11 @@ const lodash_namespaceObject = require("@modern-js/utils/lodash");
 const external_index_js_namespaceObject = require("./index.js");
 const serverAppContextTemplate = (appContext)=>{
     const { appDirectory, sharedDirectory, apiDirectory, lambdaDirectory, metaName, bffRuntimeFramework } = appContext;
+    const getRelativePathTemplate = (targetDirectory)=>`path.join(__dirname, ${JSON.stringify((0, external_index_js_namespaceObject.normalizePath)(external_node_path_default().relative(appDirectory, targetDirectory)))})`;
     return {
-        sharedDirectory: `path.join(__dirname, "${(0, external_index_js_namespaceObject.normalizePath)(external_node_path_default().relative(appDirectory, sharedDirectory))}")`,
-        apiDirectory: `path.join(__dirname, "${(0, external_index_js_namespaceObject.normalizePath)(external_node_path_default().relative(appDirectory, apiDirectory))}")`,
-        lambdaDirectory: `path.join(__dirname, "${(0, external_index_js_namespaceObject.normalizePath)(external_node_path_default().relative(appDirectory, lambdaDirectory))}")`,
+        sharedDirectory: getRelativePathTemplate(sharedDirectory),
+        apiDirectory: getRelativePathTemplate(apiDirectory),
+        lambdaDirectory: getRelativePathTemplate(lambdaDirectory),
         metaName,
         bffRuntimeFramework: bffRuntimeFramework || 'hono'
     };

package/dist/cjs/utils/register.js

@@ -33,17 +33,28 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    setupTsRuntime: ()=>setupTsRuntime
+    setupTsRuntime: ()=>setupTsRuntime,
+    resolveTsRuntimeRegisterMode: ()=>resolveTsRuntimeRegisterMode
 });
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const utils_namespaceObject = require("@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 = external_node_path_default().resolve(appDir, TS_CONFIG_FILENAME);
     const isTsProject = await utils_namespaceObject.fs.pathExists(tsconfigPath);
     const hasTsNode = (0, utils_namespaceObject.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 = (0, utils_namespaceObject.getAliasConfig)(alias, {
         appDirectory: appDir,
         tsconfigPath
@@ -68,28 +79,48 @@ const setupTsRuntime = async (appDir, distDir, alias)=>{
             [`${key}`]: tsPath
         };
     }, {});
-    const tsConfig = (0, utils_namespaceObject.readTsConfigByFile)(tsconfigPath);
-    const tsNode = await (0, utils_namespaceObject.loadFromProject)('ts-node', appDir);
-    const tsNodeOptions = tsConfig['ts-node'];
-    tsNode.register({
-        project: tsconfigPath,
-        scope: true,
-        files: true,
-        transpileOnly: true,
-        ignore: [
-            '(?:^|/)node_modules/',
-            `(?:^|/)${external_node_path_default().relative(appDir, distDir)}/`
-        ],
-        ...tsNodeOptions
-    });
+    if ('unsupported' === registerMode) return;
+    if ('ts-node' === registerMode) {
+        if ('module' === options.moduleType) {
+            const { registerModuleHooks } = await import("../esm/register-esm.js");
+            await registerModuleHooks({
+                appDir,
+                distDir,
+                alias: alias || {}
+            });
+        }
+        const tsConfig = (0, utils_namespaceObject.readTsConfigByFile)(tsconfigPath);
+        const tsNode = await (0, utils_namespaceObject.loadFromProject)('ts-node', appDir);
+        const tsNodeOptions = tsConfig['ts-node'];
+        tsNode.register({
+            project: tsconfigPath,
+            scope: true,
+            files: true,
+            transpileOnly: true,
+            ignore: [
+                '(?:^|/)node_modules/',
+                `(?:^|/)${external_node_path_default().relative(appDir, distDir)}/`
+            ],
+            ...tsNodeOptions
+        });
+    } else if ('node-loader' === registerMode) {
+        const { registerPathsLoader } = await import("../esm/register-esm.js");
+        await registerPathsLoader({
+            appDir,
+            baseUrl: absoluteBaseUrl || './',
+            paths: tsPaths
+        });
+    }
     const { register } = await import("@modern-js/utils/tsconfig-paths");
     register({
         baseUrl: absoluteBaseUrl || './',
         paths: tsPaths
     });
 };
+exports.resolveTsRuntimeRegisterMode = __webpack_exports__.resolveTsRuntimeRegisterMode;
 exports.setupTsRuntime = __webpack_exports__.setupTsRuntime;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveTsRuntimeRegisterMode",
     "setupTsRuntime"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

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

@@ -7,7 +7,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/builder/index.mjs

@@ -1,7 +1,7 @@
-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/builder/shared/builderPlugins/adapterSSR.mjs

@@ -1,9 +1,9 @@
-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) {
@@ -110,7 +110,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/builder/shared/loaders/serverModuleLoader.mjs

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

package/dist/esm/commands/build.mjs

@@ -32,15 +32,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/commands/dev.mjs

@@ -13,15 +13,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/esm/register-esm.mjs

@@ -1,19 +1,10 @@
 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;
@@ -29,4 +20,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/esm/ts-paths-loader.mjs

@@ -0,0 +1,58 @@
+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/index.mjs

@@ -15,11 +15,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 = ()=>({
@@ -120,4 +115,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/plugins/analyze/getHtmlTemplate.mjs

@@ -1,7 +1,7 @@
 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}`)));
@@ -70,7 +70,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");