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

package/dist/cjs/plugins/deploy/utils/index.js

@@ -43,9 +43,9 @@ __webpack_require__.d(__webpack_exports__, {
     readTemplate: ()=>readTemplate,
     resolveESMDependency: ()=>resolveESMDependency
 });
-const external_node_module_namespaceObject = require("node:module");
 const external_node_url_namespaceObject = require("node:url");
 const utils_namespaceObject = require("@modern-js/utils");
+const external_import_meta_resolve_namespaceObject = require("import-meta-resolve");
 const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const normalizePath = (filePath)=>filePath.replace(/\\/g, '/');
@@ -72,18 +72,21 @@ const getProjectUsage = (appDirectory, distDirectory, metaName)=>{
 };
 const getTemplatePath = (file)=>external_path_default().join(__dirname, '../platforms/templates', file);
 const readTemplate = async (file)=>(await utils_namespaceObject.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 ? (0, external_node_url_namespaceObject.pathToFileURL)(external_path_default().join(fromDirectory, 'package.json')) : (0, external_node_url_namespaceObject.pathToFileURL)(`${__dirname}/`);
     try {
-        const resolverPath = (0, external_node_url_namespaceObject.pathToFileURL)((0, external_node_module_namespaceObject.createRequire)(__filename).resolve('import-meta-resolve')).href;
-        const { moduleResolve } = await (0, utils_namespaceObject.dynamicImport)(resolverPath);
-        return normalizePath(moduleResolve(entry, (0, external_node_url_namespaceObject.pathToFileURL)(`${__dirname}/`), conditions, false).pathname.replace(/^\/(\w):/, '$1:'));
-    } catch (err) {}
+        return normalizePath((0, external_node_url_namespaceObject.fileURLToPath)((0, external_import_meta_resolve_namespaceObject.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
+        });
+    }
 };
 exports.getProjectUsage = __webpack_exports__.getProjectUsage;
 exports.getTemplatePath = __webpack_exports__.getTemplatePath;

package/dist/cjs/plugins/initialize/index.js

@@ -31,6 +31,7 @@ __webpack_require__.d(__webpack_exports__, {
     default: ()=>initialize
 });
 const utils_namespaceObject = require("@modern-js/utils");
+const lazyCompilation_js_namespaceObject = require("../../builder/shared/lazyCompilation.js");
 const index_js_namespaceObject = require("../../config/index.js");
 const initialize = ()=>({
         name: '@modern-js/plugin-initialize',
@@ -49,7 +50,8 @@ const initialize = ()=>({
                     ...defaultConfig.dev,
                     lazyCompilation: {
                         imports: true,
-                        entries: false
+                        entries: false,
+                        test: (0, lazyCompilation_js_namespaceObject.buildDefaultLazyCompilationTest)(appContext.appDirectory, appContext.internalDirectory)
                     }
                 };
                 return defaultConfig;
@@ -57,7 +59,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,
@@ -92,10 +94,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 ((0, utils_namespaceObject.isDev)() && ((0, utils_namespaceObject.isDevCommand)() || isProgrammaticDev)) return (0, utils_namespaceObject.getPort)(Number(process.env.PORT) || prodPort);
+    if ((0, utils_namespaceObject.isDev)() && (0, utils_namespaceObject.isDevCommand)()) return (0, utils_namespaceObject.getPort)(Number(process.env.PORT) || prodPort);
     return prodPort;
 }
 exports["default"] = __webpack_exports__["default"];

package/dist/cjs/plugins/serverBuild.js

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

package/dist/cjs/run/index.js

@@ -40,21 +40,21 @@ const loadPlugins_js_namespaceObject = require("../utils/loadPlugins.js");
 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(`
   ${utils_namespaceObject.chalk.bgRed.white.bold(' UNSUPPORTED NODE.JS RUNTIME ')}
 
-  ${utils_namespaceObject.chalk.red.bold(`UltraModern.js requires Node.js >=26.7.0; detected v${nodeVersion}.`)}
+  ${utils_namespaceObject.chalk.red.bold(`UltraModern.js requires Node.js >=26.10.0; detected v${nodeVersion}.`)}
   ${utils_namespaceObject.chalk.red('- Legacy Node runtimes and TypeScript transpiler fallbacks are unsupported.')}
 
   ${utils_namespaceObject.chalk.yellow('▸ Detected Runtime:')}  ${utils_namespaceObject.chalk.yellow.bold(`Node.js v${nodeVersion}`)}
-  ${utils_namespaceObject.chalk.green('▸ Required Minimum:')} ${utils_namespaceObject.chalk.green.bold('Node.js v26.7.0 or higher')}
-  ${utils_namespaceObject.chalk.green('▸ Pinned Runtime:')} ${utils_namespaceObject.chalk.green.bold('Node.js v26.7.0')}
+  ${utils_namespaceObject.chalk.green('▸ Required Minimum:')} ${utils_namespaceObject.chalk.green.bold('Node.js v26.10.0 or higher')}
+  ${utils_namespaceObject.chalk.green('▸ Pinned Runtime:')} ${utils_namespaceObject.chalk.green.bold('Node.js v26.10.0')}
 
   ${utils_namespaceObject.chalk.cyan('Immediate Action Required:')}
     ${utils_namespaceObject.chalk.gray('├──')} ${utils_namespaceObject.chalk.yellow('Recommended Upgrade')}
        ${utils_namespaceObject.chalk.bold('mise install && mise exec -- node --version')}
     ${utils_namespaceObject.chalk.gray('├──')} ${utils_namespaceObject.chalk.yellow('Manual Installation')}
-       ${utils_namespaceObject.chalk.underline('https://nodejs.org/download/release/v26.7.0/')}
+       ${utils_namespaceObject.chalk.underline('https://nodejs.org/download/release/v26.10.0/')}
      ${utils_namespaceObject.chalk.gray('└──')} ${utils_namespaceObject.chalk.yellow('Environment Verification')}
        ${utils_namespaceObject.chalk.bold('node -v && npm -v')}
 

package/dist/cjs/{plugins/serverRuntime.js → server-plugin.js}

@@ -1,5 +1,14 @@
 "use strict";
 var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
 (()=>{
     __webpack_require__.d = (exports1, getters, values)=>{
         var define = (defs, kind)=>{
@@ -27,23 +36,11 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-const __rspack_default_export = ()=>({
-        name: '@modern-js/plugin-server-runtime',
-        setup (api) {
-            api.config(()=>({
-                    output: {
-                        externals: [
-                            {
-                                '@modern-js/server-runtime': '@modern-js/server-runtime'
-                            }
-                        ]
-                    }
-                }));
-        }
-    });
-__webpack_require__.d(__webpack_exports__, {}, {
-    default: __rspack_default_export
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>server_plugin_default()
 });
+const server_plugin_namespaceObject = require("@modern-js/server-runtime-extensions/server-plugin");
+var server_plugin_default = /*#__PURE__*/ __webpack_require__.n(server_plugin_namespaceObject);
 exports["default"] = __webpack_exports__["default"];
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "default"

package/dist/cjs/types/config/base.js

@@ -0,0 +1,62 @@
+"use strict";
+var __webpack_modules__ = {
+    "./output" (module) {
+        module.exports = require("./output.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__);
+    var _output__rspack_import_0 = __webpack_require__("./output");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _output__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_output__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/types/plugin-base.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/types/plugin.js

@@ -1,5 +1,43 @@
 "use strict";
-var __webpack_require__ = {};
+var __webpack_modules__ = {
+    "./plugin-base" (module) {
+        module.exports = require("./plugin-base.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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, {
@@ -11,7 +49,13 @@ var __webpack_require__ = {};
     };
 })();
 var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _plugin_base__rspack_import_0 = __webpack_require__("./plugin-base");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _plugin_base__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_plugin_base__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/utils/initAppContext.js

@@ -59,7 +59,7 @@ const initAppContext = ({ metaName, appDirectory, runtimeConfigFile, options, te
     const moduleType = utils_namespaceObject.fs.existsSync(pkgPath) ? utils_namespaceObject.fs.readJSONSync(pkgPath).type || 'commonjs' : 'commonjs';
     return {
         runtimeConfigFile,
-        ip: utils_namespaceObject.address.ip(),
+        ip: (0, utils_namespaceObject.ip)(),
         port: 0,
         moduleType,
         apiDirectory: external_path_default().resolve(appDirectory, apiDir),

package/dist/cjs/utils/loadPlugins.js

@@ -1,5 +1,14 @@
 "use strict";
 var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
 (()=>{
     __webpack_require__.d = (exports1, getters, values)=>{
         var define = (defs, kind)=>{
@@ -32,6 +41,8 @@ __webpack_require__.d(__webpack_exports__, {
     loadInternalPlugins: ()=>loadInternalPlugins,
     loadServerPlugins: ()=>loadServerPlugins
 });
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const node_namespaceObject = require("@modern-js/server-core/node");
 const utils_namespaceObject = require("@modern-js/utils");
 const debug = (0, utils_namespaceObject.createDebugger)('load-plugins');
@@ -40,7 +51,7 @@ async function getServerPlugins(api, metaName = 'modern-js') {
     const { plugins } = await hooks._internalServerPlugins.call({
         plugins: []
     });
-    const filtedPlugins = plugins.filter((plugin)=>plugin.name.includes(metaName));
+    const filtedPlugins = plugins.filter((plugin)=>external_node_path_default().isAbsolute(plugin.name) || plugin.name.includes(metaName));
     api.updateAppContext({
         serverPlugins: filtedPlugins
     });
@@ -55,12 +66,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 = (0, utils_namespaceObject.tryResolve)(pkg, appDirectory);
-    let module;
-    try {
-        module = await (0, utils_namespaceObject.compatibleRequire)(path);
-    } catch (e) {
-        ({ default: module } = await (0, utils_namespaceObject.dynamicImport)(path));
-    }
+    const module = await (0, utils_namespaceObject.compatibleRequire)(path);
     if ('function' == typeof module) {
         const result = module(pluginOptions);
         return result;

package/dist/cjs/utils/register.js

@@ -100,7 +100,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 = (0, utils_namespaceObject.resolveServerTsconfig)(appDir, options.tsconfigPath);
     const isTsProject = await utils_namespaceObject.fs.pathExists(tsconfigPath);
     if (!isTsProject) return;

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

@@ -1,6 +1,21 @@
+import node_fs from "node:fs";
 import path from "path";
 import { createCopyInfo } from "../shared/index.mjs";
 import { createPublicPattern } from "./createCopyPattern.mjs";
+class MissingCopyContextPlugin {
+    apply(compiler) {
+        compiler.hooks.afterCompile.tap('MissingCopyContextPlugin', (compilation)=>{
+            for (const context of this.contexts)if (!node_fs.existsSync(context)) {
+                compilation.contextDependencies.delete(context);
+                compilation.missingDependencies.add(context);
+                for(let parent = path.dirname(context); parent !== path.dirname(parent) && !node_fs.existsSync(parent); parent = path.dirname(parent))compilation.missingDependencies.add(parent);
+            }
+        });
+    }
+    constructor(contexts){
+        this.contexts = contexts;
+    }
+}
 const builderPluginAdapterCopy = (options)=>({
         name: 'builder-plugin-adapter-copy',
         setup (api) {
@@ -28,8 +43,15 @@ const builderPluginAdapterCopy = (options)=>({
                                 ]
                             }
                         ]);
+                    const patterns = chain.plugin(CHAIN_ID.PLUGIN.COPY).get('args')?.[0]?.patterns ?? [];
+                    const optionalContexts = patterns.flatMap((pattern)=>pattern && 'object' == typeof pattern && 'noErrorOnMissing' in pattern && pattern.noErrorOnMissing && 'context' in pattern && 'string' == typeof pattern.context ? [
+                            path.resolve(appContext.appDirectory, pattern.context)
+                        ] : []);
+                    if (optionalContexts.length) chain.plugin('modern-missing-copy-context').use(MissingCopyContextPlugin, [
+                        optionalContexts
+                    ]);
                 }
             });
         }
     });
-export { builderPluginAdapterCopy };
+export { MissingCopyContextPlugin, builderPluginAdapterCopy };

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

@@ -14,7 +14,8 @@ function createPublicPattern(appContext, config, chain) {
         noErrorOnMissing: true,
         transform: (content, absoluteFrom)=>{
             if (!/\.html?$/.test(absoluteFrom)) return content;
-            return content.toString('utf8').replace(/<%=\s*assetPrefix\s*%>/g, removeTailSlash(chain.output.get('publicPath')));
+            const publicPath = chain.output.get('publicPath');
+            return content.toString('utf8').replace(/<%=\s*assetPrefix\s*%>/g, removeTailSlash('string' == typeof publicPath ? publicPath : ''));
         }
     };
 }

package/dist/esm/builder/index.mjs

@@ -3,5 +3,6 @@ async function createBuilderGenerator() {
     return createRspackBuilderForModern;
 }
 export { parseRspackConfig } from "@modern-js/builder";
+export { getBundleEntry } from "../plugins/analyze/getBundleEntry.mjs";
 export { builderPluginAdapterBasic, builderPluginAdapterHooks } from "./shared/builderPlugins/index.mjs";
 export { createBuilderGenerator };

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

@@ -26,7 +26,8 @@ const builderPluginAdapterHtml = (options)=>({
 async function injectAssetPrefix({ chain }) {
     const entries = chain.entryPoints.entries() || {};
     const entryNames = Object.keys(entries);
-    const assetPrefix = removeTailSlash(chain.output.get('publicPath') || '');
+    const publicPath = chain.output.get('publicPath');
+    const assetPrefix = removeTailSlash('string' == typeof publicPath ? publicPath : '');
     const code = `window.__assetPrefix__ = '${assetPrefix}';`;
     entryNames.forEach((entryName)=>{
         entries[entryName].prepend(createVirtualModule(code));

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

@@ -37,8 +37,8 @@ const builderPluginAdapterSSR = (options)=>({
                     appNormalizedConfig: normalizedConfig
                 });
                 if (isUseSSRBundle(normalizedConfig) || isUseRsc(normalizedConfig)) {
-                    await applySSRLoaderEntry(chain, options, isServer);
-                    applySSRDataLoader(chain, options);
+                    await applySSRLoaderEntry(chain, options, isServer, isServiceWorker);
+                    applySSRDataLoader(chain, options, isServer || isServiceWorker);
                 }
                 if (!isHtmlDisabled(builderConfig, target)) applyAsyncChunkHtmlPlugin({
                     chain,
@@ -123,7 +123,7 @@ function applyFilterEntriesBySSRConfig({ isProd, chain, appNormalizedConfig }) {
         if (!serverConfig?.rsc && !ssgEntries.includes(name) && !name.includes('server-loaders') && (ssr && ssrByEntries?.[name] === false || !ssr && !ssrByEntries?.[name])) chain.entryPoints.delete(name);
     });
 }
-async function applySSRLoaderEntry(chain, optinos, isServer) {
+async function applySSRLoaderEntry(chain, optinos, isServer, isServiceWorker) {
     const { appContext } = optinos;
     const { internalDirectory } = appContext;
     const { entrypoints } = appContext;
@@ -134,15 +134,17 @@ async function applySSRLoaderEntry(chain, optinos, isServer) {
             await fs.access(serverLoadersFile, fs.constants.F_OK);
             chain.entry(`${entryName}-server-loaders`).add(serverLoadersFile);
         } catch (err) {}
-        else if (isUseRsc(optinos.normalizedConfig)) chain.entry(`${entryName}-server-loaders`).add("data:text/javascript,export%20{};");
+        else if (!isServiceWorker && isUseRsc(optinos.normalizedConfig)) chain.entry(`${entryName}-server-loaders`).add("data:text/javascript,export%20{};");
     }));
 }
-function applySSRDataLoader(chain, options) {
+function applySSRDataLoader(chain, options, server) {
     const { normalizedConfig, appContext } = options;
     const { appDirectory } = appContext;
     const { entriesDir = './src' } = normalizedConfig.source;
     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();
+    chain.module.rule('ssr-data-loader').test(reg).enforce('pre').use('data-loader').loader(require.resolve('@modern-js/plugin-data-loader/loader')).options({
+        server
+    }).end();
 }
-export { builderPluginAdapterSSR, getSSRLazyCompilation };
+export { applySSRLoaderEntry, builderPluginAdapterSSR, getSSRLazyCompilation };

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

@@ -1,3 +1,4 @@
+import node_path from "node:path";
 import { collectRouteComponentFiles, normalizeModulePath } from "@modern-js/utils";
 function aggregateEagerRouteComponentFiles(byEntry) {
     const files = new Set();
@@ -20,6 +21,18 @@ function buildSSRLazyCompilationTest(eagerRouteFiles, userTest) {
         return userTestFn(m);
     };
 }
+function buildDefaultLazyCompilationTest(appDirectory, internalDirectory) {
+    let dirs;
+    return (m)=>{
+        if (!('resource' in m) || 'string' != typeof m.resource) return true;
+        dirs ??= {
+            app: normalizeModulePath(appDirectory),
+            internal: normalizeModulePath(internalDirectory)
+        };
+        const file = m.resource.split('?')[0].split(node_path.sep).join('/');
+        return file.startsWith(`${dirs.app}/`) && !file.startsWith(`${dirs.internal}/`) && !file.slice(dirs.app.length).includes('/node_modules/');
+    };
+}
 function planSSRLazyCompilation(current, info) {
     if (!current) return {
         apply: false
@@ -41,4 +54,4 @@ function planSSRLazyCompilation(current, info) {
         }
     };
 }
-export { aggregateEagerRouteComponentFiles, buildSSRLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planSSRLazyCompilation };
+export { aggregateEagerRouteComponentFiles, buildDefaultLazyCompilationTest, buildSSRLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planSSRLazyCompilation };

package/dist/esm/commands/build.mjs

@@ -56,9 +56,8 @@ const build = async (api, options)=>{
     logger.info('Starting production build...');
     if (!appContext.builder) throw new Error('Expect the Builder to have been initialized, But the appContext.builder received `undefined`');
     await appContext.builder.onAfterBuild(async ()=>copyEnvFiles(appContext.appDirectory, appContext.distDirectory));
-    const buildResult = await appContext.builder.build({
+    await appContext.builder.build({
         watch: options?.watch
     });
-    if (!options?.watch) await buildResult?.close();
 };
 export { build };

package/dist/esm/commands/deploy.mjs

@@ -1,10 +1,8 @@
 import { getServerPlugins } from "../utils/loadPlugins.mjs";
-import { build } from "./build.mjs";
 const deploy = async (api, options = {})=>{
     const hooks = api.getHooks();
     const { metaName } = api.getAppContext();
-    if (options.skipBuild) await getServerPlugins(api, metaName);
-    else await build(api);
+    await getServerPlugins(api, metaName);
     await hooks.onBeforeDeploy.call(options);
     await hooks.deploy.call();
     await hooks.onAfterDeploy.call(options);

package/dist/esm/commands/index.mjs

@@ -1,4 +1,8 @@
 import { i18n, localeKeys } from "../locale/index.mjs";
+const deployTargetOption = [
+    '--deploy-target <target>',
+    'deploy target; overrides deploy.target and MODERNJS_DEPLOY'
+];
 const devCommand = async (program, api)=>{
     program.command('dev').alias('start').usage('[options]').description(i18n.t(localeKeys.command.dev.describe)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('-e --entry [entry...]', i18n.t(localeKeys.command.dev.entry)).option('--analyze', i18n.t(localeKeys.command.shared.analyze)).option('--api-only', i18n.t(localeKeys.command.dev.apiOnly)).option('--web-only', i18n.t(localeKeys.command.dev.webOnly)).action(async (options)=>{
         const { dev } = await import("./dev.mjs");
@@ -6,7 +10,7 @@ const devCommand = async (program, api)=>{
     });
 };
 const buildCommand = async (program, api)=>{
-    program.command('build').usage('[options]').description(i18n.t(localeKeys.command.build.describe)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('--analyze', i18n.t(localeKeys.command.shared.analyze)).option('-w --watch', i18n.t(localeKeys.command.build.watch)).action(async (options)=>{
+    program.command('build').usage('[options]').description(i18n.t(localeKeys.command.build.describe)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('--analyze', i18n.t(localeKeys.command.shared.analyze)).option('-w --watch', i18n.t(localeKeys.command.build.watch)).option(...deployTargetOption).action(async (options)=>{
         const { build } = await import("./build.mjs");
         await build(api, options);
     });
@@ -18,7 +22,11 @@ const serverCommand = (program, api)=>{
     });
 };
 const deployCommand = (program, api)=>{
-    program.command('deploy').usage('[options]').option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('-s --skip-build', i18n.t(localeKeys.command.shared.skipBuild)).description(i18n.t(localeKeys.command.deploy.describe)).action(async (options)=>{
+    program.command('deploy').usage('[options]').option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('-s --skip-build', i18n.t(localeKeys.command.shared.skipBuild)).option(...deployTargetOption).description(i18n.t(localeKeys.command.deploy.describe)).action(async (options)=>{
+        if (!options.skipBuild) {
+            const { build } = await import("./build.mjs");
+            await build(api);
+        }
         const { deploy } = await import("./deploy.mjs");
         await deploy(api, options);
         process.exit(0);

package/dist/esm/compat/hooks.mjs

@@ -59,7 +59,7 @@ function handleSetupResult(setupResult, api) {
             if (newAPI && api[newAPI]) api[newAPI](async (...params)=>{
                 const { isMultiple, params: transformParams } = transformHookParams(key, params);
                 if (isMultiple) return transformHookResult(key, await fn(...transformParams));
-                return transformHookResult(key, await fn(transformParams));
+                else return transformHookResult(key, await fn(transformParams));
             });
         }
     });

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

@@ -14,8 +14,9 @@ const getParentPath = (parentURL)=>{
     } catch  {}
     return process.cwd();
 };
+const resolveSourcePath = (resolvedPath, context, defaultResolve)=>defaultResolve(context.conditions?.find((condition)=>'require' === condition || 'import' === condition) === 'require' ? resolvedPath : pathToFileURL(resolvedPath).href, context, defaultResolve);
 async function initialize({ appDir: currentAppDir, baseUrl, paths }) {
-    appDir = node_path.resolve(currentAppDir);
+    appDir = node_fs.existsSync(currentAppDir) ? node_fs.realpathSync(currentAppDir) : node_path.resolve(currentAppDir);
     matchPath = createMatchPath(baseUrl || './', paths || {});
 }
 function resolve(specifier, context, defaultResolve) {
@@ -25,12 +26,12 @@ function resolve(specifier, context, defaultResolve) {
     if ((specifier.startsWith('./') || specifier.startsWith('../')) && !node_path.extname(specifier) && isAppFile) {
         const matchedPath = node_path.resolve(parentPath, specifier);
         const resolvedPath = findSourceEntry(matchedPath) || matchedPath;
-        if (resolvedPath && node_fs.existsSync(resolvedPath)) return defaultResolve(pathToFileURL(resolvedPath).href, context, defaultResolve);
+        if (resolvedPath && node_fs.existsSync(resolvedPath)) return resolveSourcePath(resolvedPath, context, defaultResolve);
     }
-    if (!matchPath) return defaultResolve(specifier, context, defaultResolve);
+    if (!matchPath || !isAppFile) return defaultResolve(specifier, context, defaultResolve);
     const match = findMatchedSourcePath(matchPath, specifier);
     if (!match) return defaultResolve(specifier, context, defaultResolve);
     const resolvedPath = findSourceEntry(match) || match;
-    return defaultResolve(pathToFileURL(resolvedPath).href, context, defaultResolve);
+    return resolveSourcePath(resolvedPath, context, defaultResolve);
 }
 export { initialize, resolve };