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

package/dist/esm/index.mjs

@@ -1,7 +1,9 @@
+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";
@@ -11,21 +13,20 @@ 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";
 export * from "./defineConfig.mjs";
 export * from "./types/index.mjs";
-const appTools = ()=>({
+const appTools = (options = {})=>({
         name: '@modern-js/app-tools',
         usePlugins: [
-            serverRuntime(),
             compatPlugin(),
             initialize(),
             analyze(),
             serverBuild(),
-            deploy()
+            deploy(),
+            createPolicyDefaultsPlugin(options)
         ],
         post: [
             '@modern-js/plugin-initialize',
@@ -72,6 +73,11 @@ const appTools = ()=>({
                 deprecatedCommands(program);
             });
             api.onPrepare(async ()=>{
+                api.updateAppContext({
+                    deployTarget: resolveDeployTarget({
+                        configTarget: api.getNormalizedConfig().deploy?.target
+                    })
+                });
                 const command = getCommand();
                 if ('deploy' === command) {
                     const isSkipBuild = [
@@ -80,18 +86,12 @@ const appTools = ()=>({
                     ].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();
@@ -122,17 +122,10 @@ const appTools = ()=>({
                     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/plugins/analyze/getFileSystemEntry.mjs

@@ -61,6 +61,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/plugins/analyze/getServerRoutes.mjs

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

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

@@ -23,7 +23,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([
@@ -125,7 +125,7 @@ const analyze = ()=>({
                     htmlTemplates
                 };
                 api.updateAppContext(appContext);
-                if (checkIsBuildCommands(appContext.command)) {
+                if (checkIsBuildCommands()) {
                     await hooks.generateEntryCode.call({
                         entrypoints
                     });

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/server-plugin.mjs

@@ -0,0 +1 @@
+export { default } from "@modern-js/server-runtime-extensions/server-plugin";

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