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

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

@@ -1,5 +1,5 @@
 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";
@@ -9,14 +9,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;
@@ -35,10 +35,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',
@@ -48,8 +49,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/plugins/deploy/index.mjs

@@ -1,5 +1,5 @@
 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";
@@ -12,24 +12,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,
@@ -41,11 +28,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();
@@ -54,4 +39,3 @@ const deploy = ()=>({
         }
     });
 export default deploy;
-export { getSupportedDeployTargets, resolveDeployTarget };

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

@@ -1,4 +1,5 @@
 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";
@@ -71,8 +72,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/plugins/deploy/platforms/node.mjs

@@ -1,10 +1,12 @@
+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');
@@ -34,12 +36,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/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/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/plugins/deploy/platforms/vercel.mjs

@@ -1,4 +1,5 @@
 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";
@@ -91,8 +92,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/plugins/deploy/utils/index.mjs

@@ -1,6 +1,6 @@
-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";
 const normalizePath = (filePath)=>filePath.replace(/\\/g, '/');
 const getProjectUsage = (appDirectory, distDirectory, metaName)=>{
@@ -26,17 +26,20 @@ const getProjectUsage = (appDirectory, distDirectory, metaName)=>{
 };
 const getTemplatePath = (file)=>path.join(__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(`${__dirname}/`);
     try {
-        const resolverPath = pathToFileURL(createRequire(__filename).resolve('import-meta-resolve')).href;
-        const { moduleResolve } = await dynamicImport(resolverPath);
-        return normalizePath(moduleResolve(entry, pathToFileURL(`${__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/plugins/initialize/index.mjs

@@ -1,4 +1,5 @@
 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',
@@ -17,7 +18,8 @@ const initialize = ()=>({
                     ...defaultConfig.dev,
                     lazyCompilation: {
                         imports: true,
-                        entries: false
+                        entries: false,
+                        test: buildDefaultLazyCompilationTest(appContext.appDirectory, appContext.internalDirectory)
                     }
                 };
                 return defaultConfig;
@@ -25,7 +27,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,
@@ -60,10 +62,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/plugins/serverBuild.mjs

@@ -29,10 +29,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/run/index.mjs

@@ -7,21 +7,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/types/config/base.mjs

@@ -0,0 +1 @@
+export * from "./output.mjs";

package/dist/esm/types/plugin.mjs

@@ -0,0 +1 @@
+export * from "./plugin-base.mjs";

package/dist/esm/utils/initAppContext.mjs

@@ -1,4 +1,4 @@
-import { address, fs } from "@modern-js/utils";
+import { fs, ip } from "@modern-js/utils";
 import path from "path";
 function isSymlinkedNodeModules(appDirectory) {
     try {
@@ -17,7 +17,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/utils/loadPlugins.mjs

@@ -1,12 +1,13 @@
+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
     });
@@ -21,12 +22,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/utils/register.mjs

@@ -57,7 +57,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/esm-node/builder/generator/adapterCopy.mjs

@@ -1,7 +1,22 @@
 import "node:module";
+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) {
@@ -29,8 +44,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-node/builder/generator/createCopyPattern.mjs

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

@@ -4,5 +4,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-node/builder/shared/builderPlugins/adapterHtml.mjs

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

@@ -39,8 +39,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,
@@ -125,7 +125,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;
@@ -136,15 +136,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-node/builder/shared/lazyCompilation.mjs

@@ -1,4 +1,5 @@
 import "node:module";
+import node_path from "node:path";
 import { collectRouteComponentFiles, normalizeModulePath } from "@modern-js/utils";
 function aggregateEagerRouteComponentFiles(byEntry) {
     const files = new Set();
@@ -21,6 +22,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
@@ -42,4 +55,4 @@ function planSSRLazyCompilation(current, info) {
         }
     };
 }
-export { aggregateEagerRouteComponentFiles, buildSSRLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planSSRLazyCompilation };
+export { aggregateEagerRouteComponentFiles, buildDefaultLazyCompilationTest, buildSSRLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planSSRLazyCompilation };

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

@@ -57,9 +57,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-node/commands/deploy.mjs

@@ -1,11 +1,9 @@
 import "node:module";
 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-node/commands/index.mjs

@@ -1,5 +1,9 @@
 import "node:module";
 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");
@@ -7,7 +11,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);
     });
@@ -19,7 +23,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-node/compat/hooks.mjs

@@ -60,7 +60,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-node/esm/ts-paths-loader.mjs

@@ -15,8 +15,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) {
@@ -26,12 +27,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 };