@bleedingdev/modern-js-app-tools 3.9.0-ultramodern.9 → 3.9.3-ultramodern.1

package/dist/esm-node/index.mjs

@@ -1,10 +1,10 @@
-import __rslib_shim_module__ from "node:module";
-const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import "node:module";
+import { resolveDeployTarget } from "@modern-js/app-tools-extensions/deploy-output/target";
 import { createPolicyDefaultsPlugin } from "@modern-js/app-tools-extensions/policy-defaults";
 import { castArray } from "@modern-js/builder";
 import { getLocaleLanguage } from "@modern-js/i18n-utils/language-detector";
 import { createAsyncHook } from "@modern-js/plugin";
-import { cleanRequireCache, deprecatedCommands, emptyDir, getArgv, getCommand } from "@modern-js/utils";
+import { deprecatedCommands, emptyDir, getArgv, getCommand } from "@modern-js/utils";
 import path from "path";
 import { buildCommand, deployCommand, devCommand, infoCommand, inspectCommand, serverCommand } from "./commands/index.mjs";
 import { compatPlugin } from "./compat/index.mjs";
@@ -14,7 +14,6 @@ import analyze from "./plugins/analyze/index.mjs";
 import deploy from "./plugins/deploy/index.mjs";
 import initialize from "./plugins/initialize/index.mjs";
 import serverBuild from "./plugins/serverBuild.mjs";
-import serverRuntime from "./plugins/serverRuntime.mjs";
 import { generateWatchFiles } from "./utils/generateWatchFiles.mjs";
 import { initAppContext } from "./utils/initAppContext.mjs";
 import { restart } from "./utils/restart.mjs";
@@ -23,7 +22,6 @@ export * from "./types/index.mjs";
 const appTools = (options = {})=>({
         name: '@modern-js/app-tools',
         usePlugins: [
-            serverRuntime(),
             compatPlugin(),
             initialize(),
             analyze(),
@@ -76,6 +74,11 @@ const appTools = (options = {})=>({
                 deprecatedCommands(program);
             });
             api.onPrepare(async ()=>{
+                api.updateAppContext({
+                    deployTarget: resolveDeployTarget({
+                        configTarget: api.getNormalizedConfig().deploy?.target
+                    })
+                });
                 const command = getCommand();
                 if ('deploy' === command) {
                     const isSkipBuild = [
@@ -84,18 +87,12 @@ const appTools = (options = {})=>({
                     ].some((tag)=>getArgv().includes(tag));
                     if (isSkipBuild) return;
                 }
-                const { command: contextCommand } = api.getAppContext();
-                const shouldClean = [
+                if ([
                     'dev',
                     'start',
                     'build',
                     'deploy'
-                ].includes(command) || [
-                    'dev',
-                    'start',
-                    'build'
-                ].includes(contextCommand);
-                if (shouldClean) {
+                ].includes(command)) {
                     const resolvedConfig = api.getNormalizedConfig();
                     if (resolvedConfig.output.cleanDistPath) {
                         const appContext = api.getAppContext();
@@ -126,17 +123,10 @@ const appTools = (options = {})=>({
                     await restart(api.getHooks(), filename);
                 }
             });
-            api.onBeforeRestart(()=>{
-                cleanRequireCache([
-                    require.resolve('./plugins/analyze')
-                ]);
-            });
         }
     });
 const src = appTools;
 export { defineConfig } from "./defineConfig.mjs";
-export { build } from "./commands/build.mjs";
-export { deploy } from "./commands/deploy.mjs";
 export { dev } from "./commands/dev.mjs";
 export { serve } from "./commands/serve.mjs";
 export { resolveModernRsbuildConfig } from "./rsbuild.mjs";

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

@@ -62,6 +62,6 @@ const getFileSystemEntry = async (hooks, appContext, config)=>{
         }));
         return scanDir(hooks, dirs);
     } else throw Error("source.entriesDir accept a directory.");
-    throw Error(`src dir ${entriesDir} not found.`);
+    else throw Error(`src dir ${entriesDir} not found.`);
 };
 export { getFileSystemEntry, hasEntry, hasServerEntry };

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

@@ -27,7 +27,7 @@ const applyRouteOptions = (original, routeOptions)=>{
             ...original,
             urlPath: url
         };
-        {
+        else {
             const { path: urlPath, ...other } = url;
             return {
                 ...original,

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

@@ -24,7 +24,7 @@ const analyze = ()=>({
                 const resolvedConfig = api.getNormalizedConfig();
                 const hooks = api.getHooks();
                 try {
-                    if (checkIsBuildCommands(appContext.command)) fs.emptydirSync(appContext.internalDirectory);
+                    if (checkIsBuildCommands()) fs.emptydirSync(appContext.internalDirectory);
                 } catch  {}
                 const apiOnly = await isApiOnly(appContext.appDirectory, resolvedConfig.source?.entriesDir, appContext.apiDirectory);
                 const [{ getProdEntrypoints, getProdServerRoutes }] = await Promise.all([
@@ -126,7 +126,7 @@ const analyze = ()=>({
                     htmlTemplates
                 };
                 api.updateAppContext(appContext);
-                if (checkIsBuildCommands(appContext.command)) {
+                if (checkIsBuildCommands()) {
                     await hooks.generateEntryCode.call({
                         entrypoints
                     });

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

@@ -1,6 +1,6 @@
 import "node:module";
 import { JS_EXTENSIONS, getCommand, normalizeToPosixPath } from "@modern-js/utils";
-import { parse } from "es-module-lexer";
+import { init, parse } from "es-module-lexer";
 import { transform } from "esbuild";
 import fs from "fs";
 import path from "path";
@@ -10,14 +10,14 @@ const walkDirectory = (dir)=>fs.readdirSync(dir).reduce((previous, filename)=>{
             ...previous,
             ...walkDirectory(filePath)
         ];
-        return [
+        else return [
             ...previous,
             filePath
         ];
     }, []);
 const replaceWithAlias = (base, filePath, alias)=>{
     if (filePath.includes(base)) return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
-    return filePath;
+    else return filePath;
 };
 const parseModule = async ({ source, filename })=>{
     let content = source;
@@ -36,10 +36,11 @@ const parseModule = async ({ source, filename })=>{
         });
         content = result.code;
     }
-    return await parse(content);
+    await init();
+    return parse(content);
 };
 const getServerCombinedModuleFile = (internalDirectory, entryName)=>path.join(internalDirectory, entryName, 'server-loader-combined.js');
-const checkIsBuildCommands = (contextCommand)=>{
+const checkIsBuildCommands = ()=>{
     const buildCommands = [
         'dev',
         'start',
@@ -49,8 +50,7 @@ const checkIsBuildCommands = (contextCommand)=>{
         'dev-worker'
     ];
     const command = getCommand();
-    if (buildCommands.includes(command)) return true;
-    return 'dev' === contextCommand || 'start' === contextCommand || 'build' === contextCommand || 'deploy' === contextCommand;
+    return buildCommands.includes(command);
 };
 const checkIsServeCommand = ()=>{
     const command = getCommand();

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

@@ -1,6 +1,6 @@
 import "node:module";
 import { createCloudflarePreset } from "@modern-js/app-tools-extensions/cloudflare";
-import { provider } from "std-env";
+import { getDeployingTarget } from "@modern-js/app-tools-extensions/deploy-output/target";
 import { createGhPagesPreset } from "./platforms/gh-pages.mjs";
 import { createNetlifyPreset } from "./platforms/netlify.mjs";
 import { createNodePreset } from "./platforms/node.mjs";
@@ -13,24 +13,11 @@ const deployPresets = {
     ghPages: createGhPagesPreset,
     cloudflare: createCloudflarePreset
 };
-const getSupportedDeployTargets = ()=>Object.keys(deployPresets);
-const isDeployTarget = (target)=>Object.prototype.hasOwnProperty.call(deployPresets, target);
-const providerDeployTargets = {
-    vercel: 'vercel',
-    netlify: 'netlify',
-    cloudflare: 'cloudflare',
-    cloudflare_pages: 'cloudflare',
-    cloudflare_workers: 'cloudflare'
-};
-const normalizeDetectedProvider = (value)=>value ? providerDeployTargets[value] : void 0;
-const resolveDeployTarget = (modernConfig, envDeployTarget = process.env.MODERNJS_DEPLOY, detectedProvider = provider)=>modernConfig.deploy?.target || envDeployTarget || normalizeDetectedProvider(detectedProvider) || 'node';
 async function getDeployPreset(appContext, modernConfig, deployTarget, api) {
     const { appDirectory, distDirectory, metaName } = appContext;
     const { useSSR, useAPI, useWebServer } = getProjectUsage(appDirectory, distDirectory, metaName);
     const needModernServer = useSSR || useAPI || useWebServer;
-    if (!isDeployTarget(deployTarget)) throw new Error(`Unknown deploy target: '${deployTarget}'. deploy.target or MODERNJS_DEPLOY should be one of: ${getSupportedDeployTargets().join(', ')}.`);
-    const createPreset = deployPresets[deployTarget];
-    return createPreset({
+    return deployPresets[deployTarget]({
         appContext,
         modernConfig,
         needModernServer,
@@ -42,11 +29,9 @@ const deploy = ()=>({
         setup: (api)=>{
             api.deploy(async ()=>{
                 const appContext = api.getAppContext();
-                const { metaName } = appContext;
-                const modernConfig = api.getNormalizedConfig();
-                const deployTarget = resolveDeployTarget(modernConfig);
-                if ('modern-js' !== metaName && !modernConfig.deploy?.target && !process.env.MODERNJS_DEPLOY) return;
-                const deployPreset = await getDeployPreset(appContext, modernConfig, deployTarget, api);
+                const deployTarget = getDeployingTarget(appContext);
+                if (!deployTarget) return;
+                const deployPreset = await getDeployPreset(appContext, api.getNormalizedConfig(), deployTarget, api);
                 deployPreset?.prepare && await deployPreset?.prepare();
                 deployPreset?.writeOutput && await deployPreset?.writeOutput();
                 deployPreset?.genEntry && await deployPreset?.genEntry();
@@ -55,4 +40,3 @@ const deploy = ()=>({
         }
     });
 export default deploy;
-export { getSupportedDeployTargets, resolveDeployTarget };

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

@@ -1,6 +1,7 @@
 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 { traceDeployFiles } from "@modern-js/app-tools-extensions/deploy-output/trace-files";
 import { fs, removeModuleSyncFromExports } from "@modern-js/utils";
 import { nodeDepEmit } from "ndepe";
 import { isMainEntry } from "../../../utils/routes.mjs";
@@ -73,8 +74,8 @@ const createNetlifyPreset = ({ appContext, modernConfig, needModernServer })=>{
             if (!needModernServer) return;
             const entry = isEsmProject ? await resolveESMDependency('@modern-js/prod-server') : require.resolve('@modern-js/prod-server');
             const netlifyEntry = isEsmProject ? await resolveESMDependency('@modern-js/prod-server/netlify') : require.resolve('@modern-js/prod-server/netlify');
-            if (!entry || !netlifyEntry) throw new Error('Cannot find @modern-js/prod-server');
             await nodeDepEmit({
+                traceFiles: traceDeployFiles,
                 appDir: appDirectory,
                 sourceDir: funcsDirectory,
                 includeEntries: [

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

@@ -1,12 +1,14 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { createRequire } from "node:module";
 import node_path from "node:path";
+import { traceDeployFiles } from "@modern-js/app-tools-extensions/deploy-output/trace-files";
 import { chalk, fs, removeModuleSyncFromExports } from "@modern-js/utils";
 import { nodeDepEmit } from "ndepe";
 import { readTemplate, resolveESMDependency } from "../utils/index.mjs";
 import { generateHandler } from "../utils/generator.mjs";
 const createNodePreset = ({ appContext, modernConfig })=>{
-    const { appDirectory, distDirectory, moduleType } = appContext;
+    const { appDirectory, distDirectory, moduleType, serverPlugins } = appContext;
     const isEsmProject = 'module' === moduleType;
     const outputDirectory = node_path.join(appDirectory, '.output');
     const staticDirectory = node_path.join(outputDirectory, 'static');
@@ -36,12 +38,19 @@ const createNodePreset = ({ appContext, modernConfig })=>{
         async end () {
             const filter = (filePath)=>!filePath.startsWith(staticDirectory) && !filePath.endsWith('.map');
             const entry = isEsmProject ? await resolveESMDependency('@modern-js/prod-server') : require.resolve('@modern-js/prod-server');
-            if (!entry) throw new Error('Cannot find @modern-js/prod-server');
+            const requireFromApp = createRequire(node_path.join(appDirectory, 'package.json'));
+            const pluginEntries = new Set();
+            for (const plugin of serverPlugins)for (const specifier of plugin.includeEntries ?? []){
+                pluginEntries.add(requireFromApp.resolve(specifier));
+                if (isEsmProject) pluginEntries.add(await resolveESMDependency(specifier, appDirectory));
+            }
             await nodeDepEmit({
+                traceFiles: traceDeployFiles,
                 appDir: appDirectory,
                 sourceDir: outputDirectory,
                 includeEntries: [
-                    entry
+                    entry,
+                    ...pluginEntries
                 ],
                 copyWholePackage (pkgName) {
                     return '@modern-js/utils' === pkgName;

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

@@ -35,10 +35,11 @@ async function main() {
     const app = await createProdServer(prodServerOptions);
     const port = process.env.PORT || 8080;
     app.listen({
-        host: '::',
         port
     }, ()=>{
-        console.log(`\x1b[32mServer is listening on http://[::]:${port}`, '\x1b[0m');
+        const address = app.address();
+        const loopback = 'IPv6' === address.family ? '[::1]' : '127.0.0.1';
+        console.log(`\x1b[32mServer is listening on http://${loopback}:${address.port}`, '\x1b[0m');
     });
 }
 main();

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

@@ -37,10 +37,11 @@ async function main() {
     const app = await createProdServer(prodServerOptions);
     const port = process.env.PORT || 8080;
     app.listen({
-        host: '::',
         port
     }, ()=>{
-        console.log(`\x1b[32mServer is listening on http://[::]:${port}`, '\x1b[0m');
+        const address = app.address();
+        const loopback = 'IPv6' === address.family ? '[::1]' : '127.0.0.1';
+        console.log(`\x1b[32mServer is listening on http://${loopback}:${address.port}`, '\x1b[0m');
     });
 }
 main();

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

@@ -1,6 +1,7 @@
 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 { traceDeployFiles } from "@modern-js/app-tools-extensions/deploy-output/trace-files";
 import { fs, removeModuleSyncFromExports } from "@modern-js/utils";
 import { nodeDepEmit } from "ndepe";
 import { isMainEntry } from "../../../utils/routes.mjs";
@@ -93,8 +94,8 @@ const createVercelPreset = ({ appContext, modernConfig, needModernServer })=>{
         async end () {
             if (!needModernServer) return;
             const entry = isEsmProject ? await resolveESMDependency('@modern-js/prod-server') : require.resolve('@modern-js/prod-server');
-            if (!entry) throw new Error('Cannot find @modern-js/prod-server');
             await nodeDepEmit({
+                traceFiles: traceDeployFiles,
                 appDir: appDirectory,
                 sourceDir: funcsDirectory,
                 includeEntries: [

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

@@ -1,12 +1,11 @@
 import "node:module";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-import { ROUTE_SPEC_FILE, SERVER_DIR, dynamicImport, fs, getMeta } from "@modern-js/utils";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { ROUTE_SPEC_FILE, SERVER_DIR, fs, getMeta } from "@modern-js/utils";
+import { moduleResolve } from "import-meta-resolve";
 import path from "path";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
 var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
-var __rspack_import_meta_filename__ = __rspack_fileURLToPath(import.meta.url);
 const normalizePath = (filePath)=>filePath.replace(/\\/g, '/');
 const getProjectUsage = (appDirectory, distDirectory, metaName)=>{
     const routeJSON = path.join(distDirectory, ROUTE_SPEC_FILE);
@@ -31,17 +30,20 @@ const getProjectUsage = (appDirectory, distDirectory, metaName)=>{
 };
 const getTemplatePath = (file)=>path.join(__rspack_import_meta_dirname__, '../platforms/templates', file);
 const readTemplate = async (file)=>(await fs.readFile(getTemplatePath(file))).toString();
-const resolveESMDependency = async (entry)=>{
-    const conditions = new Set([
-        'node',
-        'import',
-        'module',
-        'default'
-    ]);
+const DEPLOY_CONDITIONS = [
+    'node',
+    'import',
+    'module',
+    'default'
+];
+const resolveESMDependency = async (entry, fromDirectory)=>{
+    const base = fromDirectory ? pathToFileURL(path.join(fromDirectory, 'package.json')) : pathToFileURL(`${__rspack_import_meta_dirname__}/`);
     try {
-        const resolverPath = pathToFileURL(createRequire(__rspack_import_meta_filename__).resolve('import-meta-resolve')).href;
-        const { moduleResolve } = await dynamicImport(resolverPath);
-        return normalizePath(moduleResolve(entry, pathToFileURL(`${__rspack_import_meta_dirname__}/`), conditions, false).pathname.replace(/^\/(\w):/, '$1:'));
-    } catch (err) {}
+        return normalizePath(fileURLToPath(moduleResolve(entry, base, new Set(DEPLOY_CONDITIONS), false)));
+    } catch (cause) {
+        throw new Error(`Cannot resolve "${entry}" with conditions [${DEPLOY_CONDITIONS.join(', ')}] from ${base.href}: ${cause.message}`, {
+            cause
+        });
+    }
 };
 export { getProjectUsage, getTemplatePath, normalizePath, readTemplate, resolveESMDependency };

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

@@ -1,5 +1,6 @@
 import "node:module";
 import { ensureAbsolutePath, getPort, isDev, isDevCommand } from "@modern-js/utils";
+import { buildDefaultLazyCompilationTest } from "../../builder/shared/lazyCompilation.mjs";
 import { createDefaultConfig, isLazyCompilationSafeByDefault } from "../../config/index.mjs";
 const initialize = ()=>({
         name: '@modern-js/plugin-initialize',
@@ -18,7 +19,8 @@ const initialize = ()=>({
                     ...defaultConfig.dev,
                     lazyCompilation: {
                         imports: true,
-                        entries: false
+                        entries: false,
+                        test: buildDefaultLazyCompilationTest(appContext.appDirectory, appContext.internalDirectory)
                     }
                 };
                 return defaultConfig;
@@ -26,7 +28,7 @@ const initialize = ()=>({
             api.modifyResolvedConfig(async (resolved)=>{
                 let appContext = api.getAppContext();
                 const userConfig = api.getConfig();
-                const port = await getServerPort(resolved, appContext.command);
+                const port = await getServerPort(resolved);
                 appContext = {
                     ...appContext,
                     port,
@@ -61,10 +63,9 @@ function stabilizeConfig(resolve, config, keys) {
         resolve[key] = config[key] || {};
     });
 }
-async function getServerPort(config, contextCommand) {
+async function getServerPort(config) {
     const prodPort = Number(process.env.PORT) || config.server.port || 8080;
-    const isProgrammaticDev = 'dev' === contextCommand || 'start' === contextCommand;
-    if (isDev() && (isDevCommand() || isProgrammaticDev)) return getPort(Number(process.env.PORT) || prodPort);
+    if (isDev() && isDevCommand()) return getPort(Number(process.env.PORT) || prodPort);
     return prodPort;
 }
 export default initialize;

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

@@ -30,10 +30,8 @@ const serverBuild = ()=>({
                     sourceDirs.push(serverDir);
                     if (fs.existsSync(sharedDir)) sourceDirs.push(sharedDir);
                 }
-                const { server } = modernConfig;
                 const { alias } = modernConfig.source;
                 if (sourceDirs.length > 0) await compile(appDirectory, {
-                    server,
                     alias
                 }, {
                     sourceDirs,

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

@@ -8,21 +8,21 @@ import { loadInternalPlugins } from "../utils/loadPlugins.mjs";
 async function createRunOptions({ cwd, initialLog, metaName = 'modern-js', version, internalPlugins, configFile }) {
     const nodeVersion = process.versions.node;
     const versionArr = nodeVersion.split('.').map(Number);
-    if (versionArr[0] < 26 || 26 === versionArr[0] && versionArr[1] < 7) throw new Error(`
+    if (versionArr[0] < 26 || 26 === versionArr[0] && versionArr[1] < 10) throw new Error(`
   ${chalk.bgRed.white.bold(' UNSUPPORTED NODE.JS RUNTIME ')}
 
-  ${chalk.red.bold(`UltraModern.js requires Node.js >=26.7.0; detected v${nodeVersion}.`)}
+  ${chalk.red.bold(`UltraModern.js requires Node.js >=26.10.0; detected v${nodeVersion}.`)}
   ${chalk.red('- Legacy Node runtimes and TypeScript transpiler fallbacks are unsupported.')}
 
   ${chalk.yellow('▸ Detected Runtime:')}  ${chalk.yellow.bold(`Node.js v${nodeVersion}`)}
-  ${chalk.green('▸ Required Minimum:')} ${chalk.green.bold('Node.js v26.7.0 or higher')}
-  ${chalk.green('▸ Pinned Runtime:')} ${chalk.green.bold('Node.js v26.7.0')}
+  ${chalk.green('▸ Required Minimum:')} ${chalk.green.bold('Node.js v26.10.0 or higher')}
+  ${chalk.green('▸ Pinned Runtime:')} ${chalk.green.bold('Node.js v26.10.0')}
 
   ${chalk.cyan('Immediate Action Required:')}
     ${chalk.gray('├──')} ${chalk.yellow('Recommended Upgrade')}
        ${chalk.bold('mise install && mise exec -- node --version')}
     ${chalk.gray('├──')} ${chalk.yellow('Manual Installation')}
-       ${chalk.underline('https://nodejs.org/download/release/v26.7.0/')}
+       ${chalk.underline('https://nodejs.org/download/release/v26.10.0/')}
      ${chalk.gray('└──')} ${chalk.yellow('Environment Verification')}
        ${chalk.bold('node -v && npm -v')}
 

package/dist/esm-node/types/config/base.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "./output.mjs";

package/dist/esm-node/types/plugin-base.mjs

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

package/dist/esm-node/types/plugin.mjs

@@ -1 +1,2 @@
 import "node:module";
+export * from "./plugin-base.mjs";

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

@@ -1,5 +1,5 @@
 import "node:module";
-import { address, fs } from "@modern-js/utils";
+import { fs, ip } from "@modern-js/utils";
 import path from "path";
 function isSymlinkedNodeModules(appDirectory) {
     try {
@@ -18,7 +18,7 @@ const initAppContext = ({ metaName, appDirectory, runtimeConfigFile, options, te
     const moduleType = fs.existsSync(pkgPath) ? fs.readJSONSync(pkgPath).type || 'commonjs' : 'commonjs';
     return {
         runtimeConfigFile,
-        ip: address.ip(),
+        ip: ip(),
         port: 0,
         moduleType,
         apiDirectory: path.resolve(appDirectory, apiDir),

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

@@ -1,13 +1,14 @@
 import "node:module";
+import node_path from "node:path";
 import { loadServerPlugins } from "@modern-js/server-core/node";
-import { compatibleRequire, createDebugger, dynamicImport, getInternalPlugins, tryResolve } from "@modern-js/utils";
+import { compatibleRequire, createDebugger, getInternalPlugins, tryResolve } from "@modern-js/utils";
 const debug = createDebugger('load-plugins');
 async function getServerPlugins(api, metaName = 'modern-js') {
     const hooks = api.getHooks();
     const { plugins } = await hooks._internalServerPlugins.call({
         plugins: []
     });
-    const filtedPlugins = plugins.filter((plugin)=>plugin.name.includes(metaName));
+    const filtedPlugins = plugins.filter((plugin)=>node_path.isAbsolute(plugin.name) || plugin.name.includes(metaName));
     api.updateAppContext({
         serverPlugins: filtedPlugins
     });
@@ -22,12 +23,7 @@ const resolveCliPlugin = async (p, appDirectory)=>{
     const pkg = 'string' == typeof p ? p : p[0];
     const pluginOptions = 'string' == typeof p ? void 0 : p[1];
     const path = tryResolve(pkg, appDirectory);
-    let module;
-    try {
-        module = await compatibleRequire(path);
-    } catch (e) {
-        ({ default: module } = await dynamicImport(path));
-    }
+    const module = await compatibleRequire(path);
     if ('function' == typeof module) {
         const result = module(pluginOptions);
         return result;

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

@@ -59,7 +59,7 @@ const resolveTsRuntimeRegisterMode = ()=>{
     return 'unsupported';
 };
 const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
-    if ('unsupported' === resolveTsRuntimeRegisterMode()) throw new Error(`UltraModern.js requires Node.js >=26.7.0 with native TypeScript support; detected v${process.versions.node}. Legacy TypeScript runtime transpilers are unsupported.`);
+    if ('unsupported' === resolveTsRuntimeRegisterMode()) throw new Error(`UltraModern.js requires Node.js >=26.10.0 with native TypeScript support; detected v${process.versions.node}. Legacy TypeScript runtime transpilers are unsupported.`);
     const tsconfigPath = resolveServerTsconfig(appDir, options.tsconfigPath);
     const isTsProject = await fs.pathExists(tsconfigPath);
     if (!isTsProject) return;

package/dist/types/builder/generator/adapterCopy.d.ts

@@ -1,3 +1,15 @@
-import type { RsbuildPlugin } from '@modern-js/builder';
+import type { RsbuildPlugin, Rspack } from '@modern-js/builder';
 import type { BuilderOptions } from '../shared/index.js';
+/**
+ * The copy plugin registers each pattern context as a context dependency even
+ * when the directory is absent. The watcher reports an absent context as
+ * removed right after the first build, which rebuilds every dev session once.
+ * Watch an absent context, and its absent parents, as missing instead: their
+ * later creation still rebuilds and copies.
+ */
+export declare class MissingCopyContextPlugin {
+    private readonly contexts;
+    constructor(contexts: readonly string[]);
+    apply(compiler: Rspack.Compiler): void;
+}
 export declare const builderPluginAdapterCopy: (options: BuilderOptions) => RsbuildPlugin;

package/dist/types/builder/index.d.ts

@@ -1,3 +1,4 @@
 export declare function createBuilderGenerator(): Promise<typeof import("./builder-rspack/index.js").createRspackBuilderForModern>;
 export { parseRspackConfig } from '@modern-js/builder';
+export { getBundleEntry } from '../plugins/analyze/getBundleEntry.js';
 export { builderPluginAdapterBasic, builderPluginAdapterHooks, } from './shared/builderPlugins/index.js';

package/dist/types/builder/shared/builderPlugins/adapterBasic.d.ts

@@ -1,3 +1,5 @@
+import type { AppContext, CLIPluginExtends } from '@modern-js/plugin/cli';
 import type { RsbuildPlugin } from '@rsbuild/core';
-import type { BuilderOptions } from '../types.js';
-export declare const builderPluginAdapterBasic: (options: BuilderOptions) => RsbuildPlugin;
+export declare const builderPluginAdapterBasic: <Options extends {
+    appContext: Pick<AppContext<CLIPluginExtends>, 'metaName'>;
+}>(options: Options) => RsbuildPlugin;

package/dist/types/builder/shared/builderPlugins/adapterSSR.d.ts

@@ -1,5 +1,5 @@
 import { type Rspack } from '@modern-js/builder';
-import { type RsbuildPlugin } from '@rsbuild/core';
+import { type RsbuildPlugin, type RspackChain } from '@rsbuild/core';
 import type { AppNormalizedConfig } from '../../../types/index.js';
 import type { AppToolsContext } from '../../../types/plugin.js';
 import type { BuilderOptions } from '../types.js';
@@ -12,3 +12,4 @@ export declare const builderPluginAdapterSSR: (options: BuilderOptions) => Rsbui
  * so the caller leaves the config untouched.
  */
 export declare function getSSRLazyCompilation(current: unknown, normalizedConfig: AppNormalizedConfig, appContext: AppToolsContext, eagerRouteComponentFilesByEntry: BuilderOptions['eagerRouteComponentFilesByEntry']): Rspack.LazyCompilationOptions | undefined;
+export declare function applySSRLoaderEntry(chain: RspackChain, optinos: BuilderOptions, isServer: boolean, isServiceWorker: boolean): Promise<void>;

package/dist/types/builder/shared/builderPlugins/builderHooks.d.ts

@@ -1,3 +1,11 @@
+import type { Hooks } from '@modern-js/plugin/cli';
 import type { RsbuildPlugin } from '@rsbuild/core';
-import type { BuilderOptions } from '../types.js';
-export declare const builderPluginAdapterHooks: (options: BuilderOptions) => RsbuildPlugin;
+export declare const builderPluginAdapterHooks: <Options extends {
+    appContext: {
+        _internalContext: {
+            pluginAPI?: {
+                getHooks(): Readonly<Pick<Hooks<{}, {}, {}, {}>, 'modifyBundlerChain' | 'modifyRsbuildConfig' | 'modifyRspackConfig'>>;
+            };
+        };
+    };
+}>(options: Options) => RsbuildPlugin;

package/dist/types/builder/shared/lazyCompilation.d.ts

@@ -26,6 +26,21 @@ export declare function aggregateEagerRouteComponentFiles(byEntry: EagerRouteCom
  * (defaulting to lazy when the user did not provide one).
  */
 export declare function buildSSRLazyCompilationTest(eagerRouteFiles: Set<string>, userTest?: LazyCompilationTest): LazyCompilationTestFn;
+/**
+ * Build the default dev `lazyCompilation.test`: a dynamic import is lazy only
+ * when it targets the app's own source. Everything else compiles eagerly:
+ * - the generated `<internalDirectory>/<entry>/index.jsx`, which
+ *   `bootstrap.jsx` imports as the async entry boundary Module Federation
+ *   needs to initialize shared scopes, not a code-split point;
+ * - framework and dependency modules (outside `appDirectory` or under
+ *   `node_modules`), such as plugin-i18n's backend, utils and react-i18next.
+ * Each lazy module costs one on-demand compile and HMR cycle on the first page
+ * load. Back-to-back cycles for framework imports raced on loaded CI runners
+ * ("Cannot read properties of undefined (reading 'call')"), and the app never
+ * rendered.
+ * Typed `object` so it is assignable to Rspack's `(module: Module) => boolean`.
+ */
+export declare function buildDefaultLazyCompilationTest(appDirectory: string, internalDirectory: string): (m: object) => boolean;
 export type SSRLazyPlan = {
     apply: false;
     unresolvedByEntry?: Map<string, string[]>;

package/dist/types/compat/hooks.d.ts

@@ -1,7 +1,8 @@
 import type { InternalContext } from '@modern-js/plugin';
-import type { AppTools } from '../types/index.js';
+import type { AppTools } from '../types/config/index.js';
+import type { AppToolsHookRunners } from '../types/plugin-base.js';
 /**
  * old plugin useHookRunners function result
  */
-export declare function getHookRunners(context: InternalContext<AppTools>): Record<string, any>;
+export declare function getHookRunners(context: InternalContext<AppTools>): AppToolsHookRunners;
 export declare function handleSetupResult(setupResult: Record<string, (...args: any) => any>, api: Record<string, any>): void;