@modern-js/app-tools 3.1.1 → 3.1.3

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/analyze/utils.js

@@ -68,7 +68,12 @@ const parseModule = async ({ source, filename })=>{
     if (utils_namespaceObject.JS_EXTENSIONS.some((ext)=>filename.endsWith(ext))) {
         const result = await (0, external_esbuild_namespaceObject.transform)(content, {
             loader: external_path_default().extname(filename).slice(1),
-            format: 'esm'
+            format: 'esm',
+            tsconfigRaw: {
+                compilerOptions: {
+                    experimentalDecorators: true
+                }
+            }
         });
         content = result.code;
     }

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/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/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

@@ -1,5 +1,3 @@
-export * from "./defineConfig.mjs";
-export * from "./types/index.mjs";
 import path from "path";
 import { castArray } from "@modern-js/builder";
 import { getLocaleLanguage } from "@modern-js/i18n-utils/language-detector";
@@ -17,6 +15,8 @@ import serverRuntime from "./plugins/serverRuntime.mjs";
 import { generateWatchFiles } from "./utils/generateWatchFiles.mjs";
 import { initAppContext } from "./utils/initAppContext.mjs";
 import { restart } from "./utils/restart.mjs";
+export * from "./defineConfig.mjs";
+export * from "./types/index.mjs";
 const appTools = ()=>({
         name: '@modern-js/app-tools',
         usePlugins: [

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");

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);

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/analyze/utils.mjs

@@ -23,7 +23,12 @@ const parseModule = async ({ source, filename })=>{
     if (JS_EXTENSIONS.some((ext)=>filename.endsWith(ext))) {
         const result = await transform(content, {
             loader: path.extname(filename).slice(1),
-            format: 'esm'
+            format: 'esm',
+            tsconfigRaw: {
+                compilerOptions: {
+                    experimentalDecorators: true
+                }
+            }
         });
         content = result.code;
     }

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/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/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

@@ -1,7 +1,5 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
-export * from "./defineConfig.mjs";
-export * from "./types/index.mjs";
 import path from "path";
 import { castArray } from "@modern-js/builder";
 import { getLocaleLanguage } from "@modern-js/i18n-utils/language-detector";
@@ -19,6 +17,8 @@ import serverRuntime from "./plugins/serverRuntime.mjs";
 import { generateWatchFiles } from "./utils/generateWatchFiles.mjs";
 import { initAppContext } from "./utils/initAppContext.mjs";
 import { restart } from "./utils/restart.mjs";
+export * from "./defineConfig.mjs";
+export * from "./types/index.mjs";
 const appTools = ()=>({
         name: '@modern-js/app-tools',
         usePlugins: [

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);

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/analyze/utils.mjs

@@ -24,7 +24,12 @@ const parseModule = async ({ source, filename })=>{
     if (JS_EXTENSIONS.some((ext)=>filename.endsWith(ext))) {
         const result = await transform(content, {
             loader: path.extname(filename).slice(1),
-            format: 'esm'
+            format: 'esm',
+            tsconfigRaw: {
+                compilerOptions: {
+                    experimentalDecorators: true
+                }
+            }
         });
         content = result.code;
     }

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/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'

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

@@ -2,12 +2,22 @@ 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, 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
@@ -32,24 +42,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/types/esm/register-esm.d.mts

@@ -3,3 +3,8 @@ export function registerModuleHooks({ appDir, distDir, alias }: {
     distDir: any;
     alias: any;
 }): Promise<void>;
+export function registerPathsLoader({ appDir, baseUrl, paths }: {
+    appDir: any;
+    baseUrl: any;
+    paths: any;
+}): Promise<void>;

package/dist/types/esm/ts-paths-loader.d.mts

@@ -0,0 +1,6 @@
+export function initialize({ appDir: currentAppDir, baseUrl, paths }: {
+    appDir: any;
+    baseUrl: any;
+    paths: any;
+}): Promise<void>;
+export function resolve(specifier: any, context: any, defaultResolve: any): any;

package/dist/types/utils/register.d.ts

@@ -1,7 +1,14 @@
 import { type Alias } from '@modern-js/utils';
 import type { ConfigChain } from '@rsbuild/core';
+type TsRuntimeRegisterMode = 'ts-node' | 'node-loader' | 'unsupported';
+interface TsRuntimeSetupOptions {
+    moduleType?: string;
+    preferTsNodeForServerRuntime?: boolean;
+}
+export declare const resolveTsRuntimeRegisterMode: (hasTsNode: boolean) => TsRuntimeRegisterMode;
 /**
  * Setup TypeScript runtime support.
  * Register ts-node for compilation and tsconfig-paths for path alias resolution.
  */
-export declare const setupTsRuntime: (appDir: string, distDir: string, alias?: ConfigChain<Alias>) => Promise<void>;
+export declare const setupTsRuntime: (appDir: string, distDir: string, alias?: ConfigChain<Alias>, options?: TsRuntimeSetupOptions) => Promise<void>;
+export {};

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.1.1",
+  "version": "3.1.3",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -80,33 +80,33 @@
     "modern-app": "./bin/modern.js"
   },
   "dependencies": {
-    "@babel/parser": "^7.29.0",
+    "@babel/parser": "^7.29.2",
     "@babel/traverse": "^7.29.0",
     "@babel/types": "^7.29.0",
-    "@rsbuild/core": "2.0.0-beta.4",
+    "@rsbuild/core": "2.0.0-rc.0",
     "@swc/helpers": "^0.5.17",
     "es-module-lexer": "^1.7.0",
     "esbuild": "0.25.5",
     "esbuild-register": "^3.6.0",
     "import-meta-resolve": "^4.2.0",
-    "flatted": "^3.4.0",
+    "flatted": "^3.4.2",
     "mlly": "^1.8.0",
     "ndepe": "^0.1.13",
     "pkg-types": "^1.3.1",
     "std-env": "^3.10.0",
-    "@modern-js/builder": "3.1.1",
-    "@modern-js/i18n-utils": "3.1.1",
-    "@modern-js/plugin": "3.1.1",
-    "@modern-js/plugin-data-loader": "3.1.1",
-    "@modern-js/prod-server": "3.1.1",
-    "@modern-js/server": "3.1.1",
-    "@modern-js/server-utils": "3.1.1",
-    "@modern-js/server-core": "3.1.1",
-    "@modern-js/utils": "3.1.1",
-    "@modern-js/types": "3.1.1"
+    "@modern-js/builder": "3.1.3",
+    "@modern-js/i18n-utils": "3.1.3",
+    "@modern-js/plugin-data-loader": "3.1.3",
+    "@modern-js/plugin": "3.1.3",
+    "@modern-js/prod-server": "3.1.3",
+    "@modern-js/server": "3.1.3",
+    "@modern-js/server-core": "3.1.3",
+    "@modern-js/server-utils": "3.1.3",
+    "@modern-js/types": "3.1.3",
+    "@modern-js/utils": "3.1.3"
   },
   "devDependencies": {
-    "@rslib/core": "0.20.0",
+    "@rslib/core": "0.21.0",
     "@types/babel__traverse": "7.28.0",
     "@types/node": "^20",
     "ts-node": "^10.9.2",