@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.8 → 3.9.0-ultramodern.9

package/dist/cjs/native-type-checker.js

@@ -45,9 +45,17 @@ const external_node_fs_namespaceObject = require("node:fs");
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const external_node_util_namespaceObject = require("node:util");
+const builder_namespaceObject = require("@modern-js/builder");
 const execute = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
 const native_type_checker_name = 'UltramodernNativeTypeChecker';
-const watchDependencyPath = (file)=>'win32' === process.platform ? external_node_fs_namespaceObject.realpathSync.native(file) : file;
+const watchDependencyPath = (file)=>{
+    if ('win32' !== process.platform) return file;
+    try {
+        return external_node_fs_namespaceObject.realpathSync.native(file);
+    } catch  {
+        return file;
+    }
+};
 class UltramodernNativeTypeChecker {
     async check() {
         const { configFile, build } = this.options;
@@ -83,6 +91,7 @@ class UltramodernNativeTypeChecker {
     }
     async watchInputs() {
         const inputs = new Set();
+        const missing = new Set();
         const projects = [
             this.options.configFile
         ];
@@ -91,11 +100,20 @@ class UltramodernNativeTypeChecker {
             if (visited.has(configFile)) continue;
             visited.add(configFile);
             inputs.add(configFile);
-            const config = JSON.parse(await this.run([
-                '--showConfig',
-                '--project',
-                configFile
-            ]));
+            if (!(0, external_node_fs_namespaceObject.existsSync)(configFile)) {
+                missing.add(configFile);
+                continue;
+            }
+            let config;
+            try {
+                config = JSON.parse(await this.run([
+                    '--showConfig',
+                    '--project',
+                    configFile
+                ]));
+            } catch  {
+                continue;
+            }
             const directory = external_node_path_default().dirname(configFile);
             for (const file of config.files ?? [])inputs.add(external_node_path_default().resolve(directory, file));
             for (const reference of config.references ?? []){
@@ -103,14 +121,25 @@ class UltramodernNativeTypeChecker {
                 projects.push('.json' === external_node_path_default().extname(target) ? target : external_node_path_default().join(target, 'tsconfig.json'));
             }
         }
-        return inputs;
+        return {
+            inputs,
+            missing
+        };
     }
     apply(compiler) {
         compiler.hooks.thisCompilation.tap(native_type_checker_name, (compilation)=>{
             compilation.hooks.processAssets.tapPromise(native_type_checker_name, async ()=>{
                 try {
                     compilation.fileDependencies.add(watchDependencyPath(this.options.configFile));
-                    for (const file of (await this.watchInputs()))compilation.fileDependencies.add(watchDependencyPath(file));
+                    const projectConfigFile = (0, builder_namespaceObject.refreshTsgoCheckerConfig)(this.options.configFile);
+                    if (projectConfigFile) {
+                        const watched = watchDependencyPath(projectConfigFile);
+                        compilation.fileDependencies.add(watched);
+                        if (!(0, external_node_fs_namespaceObject.existsSync)(projectConfigFile)) compilation.missingDependencies.add(watched);
+                    }
+                    const { inputs, missing } = await this.watchInputs();
+                    for (const file of inputs)compilation.fileDependencies.add(watchDependencyPath(file));
+                    for (const file of missing)compilation.missingDependencies.add(watchDependencyPath(file));
                     await this.check();
                 } catch (cause) {
                     compilation.errors.push(new Error(cause instanceof Error ? cause.message : String(cause), {

package/dist/cjs/policy-defaults.js

@@ -0,0 +1,101 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+__webpack_require__.d(__webpack_exports__, {
+    POLICY_DEFAULTS_PLUGIN_NAME: ()=>POLICY_DEFAULTS_PLUGIN_NAME,
+    RENDERER_EXTENSIONS_PACKAGE: ()=>RENDERER_EXTENSIONS_PACKAGE,
+    RENDERER_EXTENSIONS_PLUGIN_NAME: ()=>RENDERER_EXTENSIONS_PLUGIN_NAME,
+    SERVER_EXTENSIONS_PLUGIN_NAME: ()=>SERVER_EXTENSIONS_PLUGIN_NAME,
+    applyPolicyDefaults: ()=>applyPolicyDefaults,
+    createPolicyDefaultsPlugin: ()=>createPolicyDefaultsPlugin
+});
+const external_runtime_package_resolution_js_namespaceObject = require("./runtime-package-resolution.js");
+const RENDERER_EXTENSIONS_PACKAGE = '@modern-js/runtime-renderer-extensions';
+const RENDERER_EXTENSIONS_PLUGIN_NAME = 'rendererHead';
+const SERVER_EXTENSIONS_PLUGIN_NAME = '@modern-js/app-tools/server-plugin';
+const POLICY_DEFAULTS_PLUGIN_NAME = '@modern-js/ultramodern-policy-defaults';
+const applyPolicyDefaults = (api, options = {})=>{
+    if (false !== options.rendererExtensions) {
+        api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+            if (!plugins.some((plugin)=>plugin.path === RENDERER_EXTENSIONS_PACKAGE)) plugins.push({
+                name: RENDERER_EXTENSIONS_PLUGIN_NAME,
+                path: RENDERER_EXTENSIONS_PACKAGE,
+                config: {}
+            });
+            return {
+                entrypoint,
+                plugins
+            };
+        });
+        const moduleDirectories = (0, external_runtime_package_resolution_js_namespaceObject.collectRuntimePackageModuleDirectories)([
+            RENDERER_EXTENSIONS_PACKAGE
+        ], __rslib_import_meta_url__);
+        if (moduleDirectories.length > 0) api.modifyResolvedConfig((config)=>({
+                ...config,
+                builderPlugins: [
+                    ...config.builderPlugins ?? [],
+                    (0, external_runtime_package_resolution_js_namespaceObject.createRuntimePackageResolutionPlugin)(moduleDirectories)
+                ]
+            }));
+    }
+    if (false !== options.serverExtensions) api._internalServerPlugins(({ plugins })=>{
+        if (!plugins.some((plugin)=>plugin.name === SERVER_EXTENSIONS_PLUGIN_NAME)) plugins.push({
+            name: SERVER_EXTENSIONS_PLUGIN_NAME
+        });
+        return {
+            plugins
+        };
+    });
+};
+const createPolicyDefaultsPlugin = (options = {})=>({
+        name: POLICY_DEFAULTS_PLUGIN_NAME,
+        setup (api) {
+            applyPolicyDefaults(api, options);
+        }
+    });
+exports.POLICY_DEFAULTS_PLUGIN_NAME = __webpack_exports__.POLICY_DEFAULTS_PLUGIN_NAME;
+exports.RENDERER_EXTENSIONS_PACKAGE = __webpack_exports__.RENDERER_EXTENSIONS_PACKAGE;
+exports.RENDERER_EXTENSIONS_PLUGIN_NAME = __webpack_exports__.RENDERER_EXTENSIONS_PLUGIN_NAME;
+exports.SERVER_EXTENSIONS_PLUGIN_NAME = __webpack_exports__.SERVER_EXTENSIONS_PLUGIN_NAME;
+exports.applyPolicyDefaults = __webpack_exports__.applyPolicyDefaults;
+exports.createPolicyDefaultsPlugin = __webpack_exports__.createPolicyDefaultsPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "POLICY_DEFAULTS_PLUGIN_NAME",
+    "RENDERER_EXTENSIONS_PACKAGE",
+    "RENDERER_EXTENSIONS_PLUGIN_NAME",
+    "SERVER_EXTENSIONS_PLUGIN_NAME",
+    "applyPolicyDefaults",
+    "createPolicyDefaultsPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime-package-resolution.js

@@ -0,0 +1,118 @@
+"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)=>{
+            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__);
+__webpack_require__.d(__webpack_exports__, {
+    canResolveRuntimePackage: ()=>canResolveRuntimePackage,
+    collectRuntimePackageModuleDirectories: ()=>collectRuntimePackageModuleDirectories,
+    createRuntimePackageResolutionPlugin: ()=>createRuntimePackageResolutionPlugin,
+    findHostingModuleDirectory: ()=>findHostingModuleDirectory
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_url_namespaceObject = require("node:url");
+const findHostingModuleDirectory = (packageName, fromDirectory)=>{
+    let directory = external_node_path_default().resolve(fromDirectory);
+    for(;;){
+        const candidate = external_node_path_default().join(directory, 'node_modules');
+        if (external_node_fs_default().existsSync(external_node_path_default().join(candidate, packageName))) return candidate;
+        const parent = external_node_path_default().dirname(directory);
+        if (parent === directory) return;
+        directory = parent;
+    }
+};
+const collectRuntimePackageModuleDirectories = (packageNames, registrarUrl)=>{
+    const registrarDirectory = external_node_path_default().dirname((0, external_node_url_namespaceObject.fileURLToPath)(registrarUrl));
+    const directories = [];
+    for (const packageName of packageNames){
+        const directory = findHostingModuleDirectory(packageName, registrarDirectory);
+        if (directory && !directories.includes(directory)) directories.push(directory);
+    }
+    return directories;
+};
+const appendModuleDirectories = (config, directories)=>{
+    if (0 === directories.length) return;
+    config.resolve ??= {};
+    const existing = config.resolve.modules ?? [
+        'node_modules'
+    ];
+    config.resolve.modules = [
+        ...existing,
+        ...directories.filter((directory)=>!existing.includes(directory))
+    ];
+};
+const createRuntimePackageResolutionPlugin = (directories)=>({
+        name: 'ultramodern:runtime-package-resolution',
+        setup (api) {
+            api.modifyRspackConfig({
+                order: 'post',
+                handler (config) {
+                    appendModuleDirectories(config, directories);
+                }
+            });
+            api.onBeforeCreateCompiler({
+                order: 'post',
+                handler ({ bundlerConfigs }) {
+                    for (const config of bundlerConfigs)appendModuleDirectories(config, directories);
+                }
+            });
+        }
+    });
+const canResolveRuntimePackage = (packageName, registrarUrl)=>{
+    try {
+        (0, external_node_module_namespaceObject.createRequire)(registrarUrl).resolve(packageName);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+exports.canResolveRuntimePackage = __webpack_exports__.canResolveRuntimePackage;
+exports.collectRuntimePackageModuleDirectories = __webpack_exports__.collectRuntimePackageModuleDirectories;
+exports.createRuntimePackageResolutionPlugin = __webpack_exports__.createRuntimePackageResolutionPlugin;
+exports.findHostingModuleDirectory = __webpack_exports__.findHostingModuleDirectory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "canResolveRuntimePackage",
+    "collectRuntimePackageModuleDirectories",
+    "createRuntimePackageResolutionPlugin",
+    "findHostingModuleDirectory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/native-type-checker.mjs

@@ -1,10 +1,18 @@
 import { execFile } from "node:child_process";
-import { realpathSync } from "node:fs";
+import { existsSync, realpathSync } from "node:fs";
 import node_path from "node:path";
 import { promisify } from "node:util";
+import { refreshTsgoCheckerConfig } from "@modern-js/builder";
 const execute = promisify(execFile);
 const native_type_checker_name = 'UltramodernNativeTypeChecker';
-const watchDependencyPath = (file)=>'win32' === process.platform ? realpathSync.native(file) : file;
+const watchDependencyPath = (file)=>{
+    if ('win32' !== process.platform) return file;
+    try {
+        return realpathSync.native(file);
+    } catch  {
+        return file;
+    }
+};
 class UltramodernNativeTypeChecker {
     async check() {
         const { configFile, build } = this.options;
@@ -40,6 +48,7 @@ class UltramodernNativeTypeChecker {
     }
     async watchInputs() {
         const inputs = new Set();
+        const missing = new Set();
         const projects = [
             this.options.configFile
         ];
@@ -48,11 +57,20 @@ class UltramodernNativeTypeChecker {
             if (visited.has(configFile)) continue;
             visited.add(configFile);
             inputs.add(configFile);
-            const config = JSON.parse(await this.run([
-                '--showConfig',
-                '--project',
-                configFile
-            ]));
+            if (!existsSync(configFile)) {
+                missing.add(configFile);
+                continue;
+            }
+            let config;
+            try {
+                config = JSON.parse(await this.run([
+                    '--showConfig',
+                    '--project',
+                    configFile
+                ]));
+            } catch  {
+                continue;
+            }
             const directory = node_path.dirname(configFile);
             for (const file of config.files ?? [])inputs.add(node_path.resolve(directory, file));
             for (const reference of config.references ?? []){
@@ -60,14 +78,25 @@ class UltramodernNativeTypeChecker {
                 projects.push('.json' === node_path.extname(target) ? target : node_path.join(target, 'tsconfig.json'));
             }
         }
-        return inputs;
+        return {
+            inputs,
+            missing
+        };
     }
     apply(compiler) {
         compiler.hooks.thisCompilation.tap(native_type_checker_name, (compilation)=>{
             compilation.hooks.processAssets.tapPromise(native_type_checker_name, async ()=>{
                 try {
                     compilation.fileDependencies.add(watchDependencyPath(this.options.configFile));
-                    for (const file of (await this.watchInputs()))compilation.fileDependencies.add(watchDependencyPath(file));
+                    const projectConfigFile = refreshTsgoCheckerConfig(this.options.configFile);
+                    if (projectConfigFile) {
+                        const watched = watchDependencyPath(projectConfigFile);
+                        compilation.fileDependencies.add(watched);
+                        if (!existsSync(projectConfigFile)) compilation.missingDependencies.add(watched);
+                    }
+                    const { inputs, missing } = await this.watchInputs();
+                    for (const file of inputs)compilation.fileDependencies.add(watchDependencyPath(file));
+                    for (const file of missing)compilation.missingDependencies.add(watchDependencyPath(file));
                     await this.check();
                 } catch (cause) {
                     compilation.errors.push(new Error(cause instanceof Error ? cause.message : String(cause), {

package/dist/esm/policy-defaults.mjs

@@ -0,0 +1,45 @@
+import { collectRuntimePackageModuleDirectories, createRuntimePackageResolutionPlugin } from "./runtime-package-resolution.mjs";
+const RENDERER_EXTENSIONS_PACKAGE = '@modern-js/runtime-renderer-extensions';
+const RENDERER_EXTENSIONS_PLUGIN_NAME = 'rendererHead';
+const SERVER_EXTENSIONS_PLUGIN_NAME = '@modern-js/app-tools/server-plugin';
+const POLICY_DEFAULTS_PLUGIN_NAME = '@modern-js/ultramodern-policy-defaults';
+const applyPolicyDefaults = (api, options = {})=>{
+    if (false !== options.rendererExtensions) {
+        api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+            if (!plugins.some((plugin)=>plugin.path === RENDERER_EXTENSIONS_PACKAGE)) plugins.push({
+                name: RENDERER_EXTENSIONS_PLUGIN_NAME,
+                path: RENDERER_EXTENSIONS_PACKAGE,
+                config: {}
+            });
+            return {
+                entrypoint,
+                plugins
+            };
+        });
+        const moduleDirectories = collectRuntimePackageModuleDirectories([
+            RENDERER_EXTENSIONS_PACKAGE
+        ], import.meta.url);
+        if (moduleDirectories.length > 0) api.modifyResolvedConfig((config)=>({
+                ...config,
+                builderPlugins: [
+                    ...config.builderPlugins ?? [],
+                    createRuntimePackageResolutionPlugin(moduleDirectories)
+                ]
+            }));
+    }
+    if (false !== options.serverExtensions) api._internalServerPlugins(({ plugins })=>{
+        if (!plugins.some((plugin)=>plugin.name === SERVER_EXTENSIONS_PLUGIN_NAME)) plugins.push({
+            name: SERVER_EXTENSIONS_PLUGIN_NAME
+        });
+        return {
+            plugins
+        };
+    });
+};
+const createPolicyDefaultsPlugin = (options = {})=>({
+        name: POLICY_DEFAULTS_PLUGIN_NAME,
+        setup (api) {
+            applyPolicyDefaults(api, options);
+        }
+    });
+export { POLICY_DEFAULTS_PLUGIN_NAME, RENDERER_EXTENSIONS_PACKAGE, RENDERER_EXTENSIONS_PLUGIN_NAME, SERVER_EXTENSIONS_PLUGIN_NAME, applyPolicyDefaults, createPolicyDefaultsPlugin };

package/dist/esm/runtime-package-resolution.mjs

@@ -0,0 +1,60 @@
+import node_fs from "node:fs";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+const findHostingModuleDirectory = (packageName, fromDirectory)=>{
+    let directory = node_path.resolve(fromDirectory);
+    for(;;){
+        const candidate = node_path.join(directory, 'node_modules');
+        if (node_fs.existsSync(node_path.join(candidate, packageName))) return candidate;
+        const parent = node_path.dirname(directory);
+        if (parent === directory) return;
+        directory = parent;
+    }
+};
+const collectRuntimePackageModuleDirectories = (packageNames, registrarUrl)=>{
+    const registrarDirectory = node_path.dirname(fileURLToPath(registrarUrl));
+    const directories = [];
+    for (const packageName of packageNames){
+        const directory = findHostingModuleDirectory(packageName, registrarDirectory);
+        if (directory && !directories.includes(directory)) directories.push(directory);
+    }
+    return directories;
+};
+const appendModuleDirectories = (config, directories)=>{
+    if (0 === directories.length) return;
+    config.resolve ??= {};
+    const existing = config.resolve.modules ?? [
+        'node_modules'
+    ];
+    config.resolve.modules = [
+        ...existing,
+        ...directories.filter((directory)=>!existing.includes(directory))
+    ];
+};
+const createRuntimePackageResolutionPlugin = (directories)=>({
+        name: 'ultramodern:runtime-package-resolution',
+        setup (api) {
+            api.modifyRspackConfig({
+                order: 'post',
+                handler (config) {
+                    appendModuleDirectories(config, directories);
+                }
+            });
+            api.onBeforeCreateCompiler({
+                order: 'post',
+                handler ({ bundlerConfigs }) {
+                    for (const config of bundlerConfigs)appendModuleDirectories(config, directories);
+                }
+            });
+        }
+    });
+const canResolveRuntimePackage = (packageName, registrarUrl)=>{
+    try {
+        createRequire(registrarUrl).resolve(packageName);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+export { canResolveRuntimePackage, collectRuntimePackageModuleDirectories, createRuntimePackageResolutionPlugin, findHostingModuleDirectory };

package/dist/esm-node/native-type-checker.mjs

@@ -1,11 +1,19 @@
 import "node:module";
 import { execFile } from "node:child_process";
-import { realpathSync } from "node:fs";
+import { existsSync, realpathSync } from "node:fs";
 import node_path from "node:path";
 import { promisify } from "node:util";
+import { refreshTsgoCheckerConfig } from "@modern-js/builder";
 const execute = promisify(execFile);
 const native_type_checker_name = 'UltramodernNativeTypeChecker';
-const watchDependencyPath = (file)=>'win32' === process.platform ? realpathSync.native(file) : file;
+const watchDependencyPath = (file)=>{
+    if ('win32' !== process.platform) return file;
+    try {
+        return realpathSync.native(file);
+    } catch  {
+        return file;
+    }
+};
 class UltramodernNativeTypeChecker {
     async check() {
         const { configFile, build } = this.options;
@@ -41,6 +49,7 @@ class UltramodernNativeTypeChecker {
     }
     async watchInputs() {
         const inputs = new Set();
+        const missing = new Set();
         const projects = [
             this.options.configFile
         ];
@@ -49,11 +58,20 @@ class UltramodernNativeTypeChecker {
             if (visited.has(configFile)) continue;
             visited.add(configFile);
             inputs.add(configFile);
-            const config = JSON.parse(await this.run([
-                '--showConfig',
-                '--project',
-                configFile
-            ]));
+            if (!existsSync(configFile)) {
+                missing.add(configFile);
+                continue;
+            }
+            let config;
+            try {
+                config = JSON.parse(await this.run([
+                    '--showConfig',
+                    '--project',
+                    configFile
+                ]));
+            } catch  {
+                continue;
+            }
             const directory = node_path.dirname(configFile);
             for (const file of config.files ?? [])inputs.add(node_path.resolve(directory, file));
             for (const reference of config.references ?? []){
@@ -61,14 +79,25 @@ class UltramodernNativeTypeChecker {
                 projects.push('.json' === node_path.extname(target) ? target : node_path.join(target, 'tsconfig.json'));
             }
         }
-        return inputs;
+        return {
+            inputs,
+            missing
+        };
     }
     apply(compiler) {
         compiler.hooks.thisCompilation.tap(native_type_checker_name, (compilation)=>{
             compilation.hooks.processAssets.tapPromise(native_type_checker_name, async ()=>{
                 try {
                     compilation.fileDependencies.add(watchDependencyPath(this.options.configFile));
-                    for (const file of (await this.watchInputs()))compilation.fileDependencies.add(watchDependencyPath(file));
+                    const projectConfigFile = refreshTsgoCheckerConfig(this.options.configFile);
+                    if (projectConfigFile) {
+                        const watched = watchDependencyPath(projectConfigFile);
+                        compilation.fileDependencies.add(watched);
+                        if (!existsSync(projectConfigFile)) compilation.missingDependencies.add(watched);
+                    }
+                    const { inputs, missing } = await this.watchInputs();
+                    for (const file of inputs)compilation.fileDependencies.add(watchDependencyPath(file));
+                    for (const file of missing)compilation.missingDependencies.add(watchDependencyPath(file));
                     await this.check();
                 } catch (cause) {
                     compilation.errors.push(new Error(cause instanceof Error ? cause.message : String(cause), {

package/dist/esm-node/policy-defaults.mjs

@@ -0,0 +1,46 @@
+import "node:module";
+import { collectRuntimePackageModuleDirectories, createRuntimePackageResolutionPlugin } from "./runtime-package-resolution.mjs";
+const RENDERER_EXTENSIONS_PACKAGE = '@modern-js/runtime-renderer-extensions';
+const RENDERER_EXTENSIONS_PLUGIN_NAME = 'rendererHead';
+const SERVER_EXTENSIONS_PLUGIN_NAME = '@modern-js/app-tools/server-plugin';
+const POLICY_DEFAULTS_PLUGIN_NAME = '@modern-js/ultramodern-policy-defaults';
+const applyPolicyDefaults = (api, options = {})=>{
+    if (false !== options.rendererExtensions) {
+        api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+            if (!plugins.some((plugin)=>plugin.path === RENDERER_EXTENSIONS_PACKAGE)) plugins.push({
+                name: RENDERER_EXTENSIONS_PLUGIN_NAME,
+                path: RENDERER_EXTENSIONS_PACKAGE,
+                config: {}
+            });
+            return {
+                entrypoint,
+                plugins
+            };
+        });
+        const moduleDirectories = collectRuntimePackageModuleDirectories([
+            RENDERER_EXTENSIONS_PACKAGE
+        ], import.meta.url);
+        if (moduleDirectories.length > 0) api.modifyResolvedConfig((config)=>({
+                ...config,
+                builderPlugins: [
+                    ...config.builderPlugins ?? [],
+                    createRuntimePackageResolutionPlugin(moduleDirectories)
+                ]
+            }));
+    }
+    if (false !== options.serverExtensions) api._internalServerPlugins(({ plugins })=>{
+        if (!plugins.some((plugin)=>plugin.name === SERVER_EXTENSIONS_PLUGIN_NAME)) plugins.push({
+            name: SERVER_EXTENSIONS_PLUGIN_NAME
+        });
+        return {
+            plugins
+        };
+    });
+};
+const createPolicyDefaultsPlugin = (options = {})=>({
+        name: POLICY_DEFAULTS_PLUGIN_NAME,
+        setup (api) {
+            applyPolicyDefaults(api, options);
+        }
+    });
+export { POLICY_DEFAULTS_PLUGIN_NAME, RENDERER_EXTENSIONS_PACKAGE, RENDERER_EXTENSIONS_PLUGIN_NAME, SERVER_EXTENSIONS_PLUGIN_NAME, applyPolicyDefaults, createPolicyDefaultsPlugin };

package/dist/esm-node/runtime-package-resolution.mjs

@@ -0,0 +1,61 @@
+import "node:module";
+import node_fs from "node:fs";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+const findHostingModuleDirectory = (packageName, fromDirectory)=>{
+    let directory = node_path.resolve(fromDirectory);
+    for(;;){
+        const candidate = node_path.join(directory, 'node_modules');
+        if (node_fs.existsSync(node_path.join(candidate, packageName))) return candidate;
+        const parent = node_path.dirname(directory);
+        if (parent === directory) return;
+        directory = parent;
+    }
+};
+const collectRuntimePackageModuleDirectories = (packageNames, registrarUrl)=>{
+    const registrarDirectory = node_path.dirname(fileURLToPath(registrarUrl));
+    const directories = [];
+    for (const packageName of packageNames){
+        const directory = findHostingModuleDirectory(packageName, registrarDirectory);
+        if (directory && !directories.includes(directory)) directories.push(directory);
+    }
+    return directories;
+};
+const appendModuleDirectories = (config, directories)=>{
+    if (0 === directories.length) return;
+    config.resolve ??= {};
+    const existing = config.resolve.modules ?? [
+        'node_modules'
+    ];
+    config.resolve.modules = [
+        ...existing,
+        ...directories.filter((directory)=>!existing.includes(directory))
+    ];
+};
+const createRuntimePackageResolutionPlugin = (directories)=>({
+        name: 'ultramodern:runtime-package-resolution',
+        setup (api) {
+            api.modifyRspackConfig({
+                order: 'post',
+                handler (config) {
+                    appendModuleDirectories(config, directories);
+                }
+            });
+            api.onBeforeCreateCompiler({
+                order: 'post',
+                handler ({ bundlerConfigs }) {
+                    for (const config of bundlerConfigs)appendModuleDirectories(config, directories);
+                }
+            });
+        }
+    });
+const canResolveRuntimePackage = (packageName, registrarUrl)=>{
+    try {
+        createRequire(registrarUrl).resolve(packageName);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+export { canResolveRuntimePackage, collectRuntimePackageModuleDirectories, createRuntimePackageResolutionPlugin, findHostingModuleDirectory };

package/dist/types/policy-defaults.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The fork's renderer policy (head rendering, HTML template assembly and asset
+ * ordering) and server policy (localised loaders, error responses, telemetry,
+ * module-federation CSS and asset cache headers, static serving) are the
+ * default behaviour of an UltraModern.js app.
+ *
+ * They live in their own packages so they can also be composed explicitly, but
+ * a plain `appTools()` app gets them without opting in — that is what this fork
+ * has always done. Pass `appTools({ rendererExtensions: false })` or
+ * `appTools({ serverExtensions: false })` to run without them.
+ */
+export declare const RENDERER_EXTENSIONS_PACKAGE = "@modern-js/runtime-renderer-extensions";
+export declare const RENDERER_EXTENSIONS_PLUGIN_NAME = "rendererHead";
+export declare const SERVER_EXTENSIONS_PLUGIN_NAME = "@modern-js/app-tools/server-plugin";
+export interface PolicyDefaultsOptions {
+    /** Default `true`. Set to `false` to drop the fork's renderer policy. */
+    rendererExtensions?: boolean;
+    /** Default `true`. Set to `false` to drop the fork's server policy. */
+    serverExtensions?: boolean;
+}
+/**
+ * The subset of the CLI plugin API these defaults use. Typed structurally, and
+ * loosely at the hook boundary, so this package stays free of a dependency on
+ * the solution that consumes it — which depends on this one.
+ */
+export interface PolicyDefaultsPluginApi {
+    _internalRuntimePlugins(fn: (input: any) => any): void;
+    _internalServerPlugins(fn: (input: any) => any): void;
+    modifyResolvedConfig(fn: (config: any) => any): void;
+}
+export declare const POLICY_DEFAULTS_PLUGIN_NAME = "@modern-js/ultramodern-policy-defaults";
+/** Registers the fork's default renderer and server policy. */
+export declare const applyPolicyDefaults: (api: PolicyDefaultsPluginApi, options?: PolicyDefaultsOptions) => void;
+/**
+ * The fork defaults as a CLI plugin.
+ *
+ * The descriptor this registers may land before the ones it wraps — CLI
+ * ordering cannot be constrained here without a cycle, because the plugins
+ * that emit those descriptors are themselves ordered after `appTools()`.
+ * Ordering is settled on the runtime side instead: `rendererHeadPlugin`
+ * declares the runtime plugins that run before it.
+ */
+export declare const createPolicyDefaultsPlugin: (options?: PolicyDefaultsOptions) => {
+    name: string;
+    setup(api: PolicyDefaultsPluginApi): void;
+};

package/dist/types/runtime-package-resolution.d.ts

@@ -0,0 +1,28 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+/**
+ * A generated `runtime-register.js` lives inside the *application*, so every
+ * runtime plugin it imports has to resolve from the application's own
+ * `node_modules`. Packages registered by a CLI plugin are dependencies of that
+ * CLI plugin, not of the application, and under an isolated (pnpm) linker the
+ * application cannot see them — the build fails with `Module not found`.
+ *
+ * Instead of freezing a single resolved file (which would lock one export
+ * condition and break the web/node split), the registering package contributes
+ * the `node_modules` directory that actually hosts the package as a *fallback*
+ * module directory. Bare specifiers keep their normal `exports` resolution, the
+ * application's own copy still wins when it declares the dependency, and both
+ * the workspace source layout and a published pnpm layout work.
+ */
+export declare const findHostingModuleDirectory: (packageName: string, fromDirectory: string) => string | undefined;
+/**
+ * Collect the fallback module directories for the given packages, starting the
+ * search at the module that registers them.
+ */
+export declare const collectRuntimePackageModuleDirectories: (packageNames: readonly string[], registrarUrl: string) => string[];
+/**
+ * Rsbuild plugin that adds the given directories as fallback module roots for
+ * every environment (web, node and worker bundles alike).
+ */
+export declare const createRuntimePackageResolutionPlugin: (directories: readonly string[]) => RsbuildPlugin;
+/** `true` when the package resolves from the registering module at all. */
+export declare const canResolveRuntimePackage: (packageName: string, registrarUrl: string) => boolean;

package/package.json

@@ -11,7 +11,7 @@
     "directory": "packages/solutions/app-tools-extensions"
   },
   "license": "MIT",
-  "version": "3.9.0-ultramodern.8",
+  "version": "3.9.0-ultramodern.9",
   "files": [
     "dist",
     "src"
@@ -87,6 +87,16 @@
       "import": "./dist/esm-node/native-type-checker.mjs",
       "require": "./dist/cjs/native-type-checker.js"
     },
+    "./runtime-package-resolution": {
+      "types": "./dist/types/runtime-package-resolution.d.ts",
+      "import": "./dist/esm-node/runtime-package-resolution.mjs",
+      "require": "./dist/cjs/runtime-package-resolution.js"
+    },
+    "./policy-defaults": {
+      "types": "./dist/types/policy-defaults.d.ts",
+      "import": "./dist/esm-node/policy-defaults.mjs",
+      "require": "./dist/cjs/policy-defaults.js"
+    },
     "./build-config/precompress/plugin": {
       "types": "./dist/types/build-config/precompress/plugin.d.ts",
       "import": "./dist/esm-node/build-config/precompress/plugin.mjs",
@@ -135,13 +145,14 @@
     "@babel/parser": "^8.0.4",
     "@babel/traverse": "^8.0.4",
     "@loadable/component": "5.16.7",
-    "@modern-js/backend-federation-contracts": "npm:@bleedingdev/modern-js-backend-federation-contracts@3.9.0-ultramodern.8",
-    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.0-ultramodern.8",
-    "@modern-js/prod-server": "npm:@bleedingdev/modern-js-prod-server@3.9.0-ultramodern.8",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.8",
-    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.0-ultramodern.8",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.8",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.8",
+    "@modern-js/backend-federation-contracts": "npm:@bleedingdev/modern-js-backend-federation-contracts@3.9.0-ultramodern.9",
+    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.0-ultramodern.9",
+    "@modern-js/prod-server": "npm:@bleedingdev/modern-js-prod-server@3.9.0-ultramodern.9",
+    "@modern-js/runtime-renderer-extensions": "npm:@bleedingdev/modern-js-runtime-renderer-extensions@3.9.0-ultramodern.9",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.9",
+    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.0-ultramodern.9",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.9",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.9",
     "@swc/helpers": "^0.5.23",
     "compression-webpack-plugin": "^12.0.0",
     "esbuild": "^0.28.2",
@@ -151,8 +162,8 @@
     "@rsbuild/core": "2.2.3"
   },
   "devDependencies": {
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.8",
-    "@modern-js/plugin-bff-extensions": "npm:@bleedingdev/modern-js-plugin-bff-extensions@3.9.0-ultramodern.8",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.9",
+    "@modern-js/plugin-bff-extensions": "npm:@bleedingdev/modern-js-plugin-bff-extensions@3.9.0-ultramodern.9",
     "@module-federation/runtime-tools": "2.9.0",
     "@rsbuild/core": "2.2.3",
     "@rslib/core": "1.0.0",

package/src/native-type-checker.ts

@@ -1,15 +1,24 @@
 import { execFile } from 'node:child_process';
-import { realpathSync } from 'node:fs';
+import { existsSync, realpathSync } from 'node:fs';
 import path from 'node:path';
 import { promisify } from 'node:util';
+import { refreshTsgoCheckerConfig } from '@modern-js/builder';
 import type { Rspack, RspackChain } from '@rsbuild/core';
 
 const execute = promisify(execFile);
 const name = 'UltramodernNativeTypeChecker';
 
 // Windows file events expand 8.3 aliases; register the same native path spelling.
-const watchDependencyPath = (file: string): string =>
-  process.platform === 'win32' ? realpathSync.native(file) : file;
+// A path that does not exist yet (a project tsconfig mid-edit) cannot be
+// realpathed; it is registered as spelled so its return still triggers a build.
+const watchDependencyPath = (file: string): string => {
+  if (process.platform !== 'win32') return file;
+  try {
+    return realpathSync.native(file);
+  } catch {
+    return file;
+  }
+};
 
 export class UltramodernNativeTypeChecker {
   constructor(
@@ -45,20 +54,33 @@ export class UltramodernNativeTypeChecker {
     }
   }
 
-  private async watchInputs(): Promise<Set<string>> {
+  private async watchInputs(): Promise<{
+    inputs: Set<string>;
+    missing: Set<string>;
+  }> {
     const inputs = new Set<string>();
+    const missing = new Set<string>();
     const projects = [this.options.configFile];
     const visited = new Set<string>();
     for (const configFile of projects) {
       if (visited.has(configFile)) continue;
       visited.add(configFile);
+      // Registered before it is parsed: a referenced config that is absent or
+      // unparsable right now must still be watched, or creating or repairing
+      // it never re-triggers the compilation. `check()` reports the error.
       inputs.add(configFile);
-      const config = JSON.parse(
-        await this.run(['--showConfig', '--project', configFile]),
-      ) as {
-        files?: string[];
-        references?: { path: string }[];
-      };
+      if (!existsSync(configFile)) {
+        missing.add(configFile);
+        continue;
+      }
+      let config: { files?: string[]; references?: { path: string }[] };
+      try {
+        config = JSON.parse(
+          await this.run(['--showConfig', '--project', configFile]),
+        );
+      } catch {
+        continue;
+      }
       const directory = path.dirname(configFile);
       for (const file of config.files ?? [])
         inputs.add(path.resolve(directory, file));
@@ -71,7 +93,7 @@ export class UltramodernNativeTypeChecker {
         );
       }
     }
-    return inputs;
+    return { inputs, missing };
   }
 
   apply(compiler: Rspack.Compiler): void {
@@ -81,8 +103,28 @@ export class UltramodernNativeTypeChecker {
           compilation.fileDependencies.add(
             watchDependencyPath(this.options.configFile),
           );
-          for (const file of await this.watchInputs())
+          // A generated checker config restates values TypeScript does not
+          // inherit through `extends` (project references above all). Rebuild
+          // it from the project's own tsconfig before every check, and watch
+          // that tsconfig, so an edit during `modern dev` reaches the next
+          // compilation instead of the next restart.
+          const projectConfigFile = refreshTsgoCheckerConfig(
+            this.options.configFile,
+          );
+          if (projectConfigFile) {
+            const watched = watchDependencyPath(projectConfigFile);
+            compilation.fileDependencies.add(watched);
+            // Absent mid-edit: a missing dependency makes its (re)appearance
+            // a rebuild trigger, so the dev server recovers on its own.
+            if (!existsSync(projectConfigFile)) {
+              compilation.missingDependencies.add(watched);
+            }
+          }
+          const { inputs, missing } = await this.watchInputs();
+          for (const file of inputs)
             compilation.fileDependencies.add(watchDependencyPath(file));
+          for (const file of missing)
+            compilation.missingDependencies.add(watchDependencyPath(file));
           await this.check();
         } catch (cause) {
           compilation.errors.push(

package/src/policy-defaults.ts

@@ -0,0 +1,127 @@
+import {
+  collectRuntimePackageModuleDirectories,
+  createRuntimePackageResolutionPlugin,
+} from './runtime-package-resolution';
+
+/**
+ * The fork's renderer policy (head rendering, HTML template assembly and asset
+ * ordering) and server policy (localised loaders, error responses, telemetry,
+ * module-federation CSS and asset cache headers, static serving) are the
+ * default behaviour of an UltraModern.js app.
+ *
+ * They live in their own packages so they can also be composed explicitly, but
+ * a plain `appTools()` app gets them without opting in — that is what this fork
+ * has always done. Pass `appTools({ rendererExtensions: false })` or
+ * `appTools({ serverExtensions: false })` to run without them.
+ */
+export const RENDERER_EXTENSIONS_PACKAGE =
+  '@modern-js/runtime-renderer-extensions';
+
+export const RENDERER_EXTENSIONS_PLUGIN_NAME = 'rendererHead';
+
+export const SERVER_EXTENSIONS_PLUGIN_NAME =
+  '@modern-js/app-tools/server-plugin';
+
+export interface PolicyDefaultsOptions {
+  /** Default `true`. Set to `false` to drop the fork's renderer policy. */
+  rendererExtensions?: boolean;
+  /** Default `true`. Set to `false` to drop the fork's server policy. */
+  serverExtensions?: boolean;
+}
+
+type RuntimePluginDescriptor = {
+  name?: string;
+  path: string;
+  config?: unknown;
+};
+
+type ServerPluginDescriptor = { name: string };
+
+/**
+ * The subset of the CLI plugin API these defaults use. Typed structurally, and
+ * loosely at the hook boundary, so this package stays free of a dependency on
+ * the solution that consumes it — which depends on this one.
+ */
+export interface PolicyDefaultsPluginApi {
+  _internalRuntimePlugins(fn: (input: any) => any): void;
+  _internalServerPlugins(fn: (input: any) => any): void;
+  modifyResolvedConfig(fn: (config: any) => any): void;
+}
+
+type RuntimePluginsInput = {
+  entrypoint: unknown;
+  plugins: RuntimePluginDescriptor[];
+};
+
+type ServerPluginsInput = { plugins: ServerPluginDescriptor[] };
+
+export const POLICY_DEFAULTS_PLUGIN_NAME =
+  '@modern-js/ultramodern-policy-defaults';
+
+/** Registers the fork's default renderer and server policy. */
+export const applyPolicyDefaults = (
+  api: PolicyDefaultsPluginApi,
+  options: PolicyDefaultsOptions = {},
+): void => {
+  if (options.rendererExtensions !== false) {
+    api._internalRuntimePlugins(
+      ({ entrypoint, plugins }: RuntimePluginsInput) => {
+        // An explicit composition (`ultramodernAppTools()`) may already have
+        // registered it; the descriptor list must stay free of duplicates.
+        if (
+          !plugins.some(plugin => plugin.path === RENDERER_EXTENSIONS_PACKAGE)
+        ) {
+          plugins.push({
+            name: RENDERER_EXTENSIONS_PLUGIN_NAME,
+            path: RENDERER_EXTENSIONS_PACKAGE,
+            config: {},
+          });
+        }
+        return { entrypoint, plugins };
+      },
+    );
+
+    const moduleDirectories = collectRuntimePackageModuleDirectories(
+      [RENDERER_EXTENSIONS_PACKAGE],
+      import.meta.url,
+    );
+    if (moduleDirectories.length > 0) {
+      api.modifyResolvedConfig(config => ({
+        ...config,
+        builderPlugins: [
+          ...(config.builderPlugins ?? []),
+          createRuntimePackageResolutionPlugin(moduleDirectories),
+        ],
+      }));
+    }
+  }
+
+  if (options.serverExtensions !== false) {
+    api._internalServerPlugins(({ plugins }: ServerPluginsInput) => {
+      if (
+        !plugins.some(plugin => plugin.name === SERVER_EXTENSIONS_PLUGIN_NAME)
+      ) {
+        plugins.push({ name: SERVER_EXTENSIONS_PLUGIN_NAME });
+      }
+      return { plugins };
+    });
+  }
+};
+
+/**
+ * The fork defaults as a CLI plugin.
+ *
+ * The descriptor this registers may land before the ones it wraps — CLI
+ * ordering cannot be constrained here without a cycle, because the plugins
+ * that emit those descriptors are themselves ordered after `appTools()`.
+ * Ordering is settled on the runtime side instead: `rendererHeadPlugin`
+ * declares the runtime plugins that run before it.
+ */
+export const createPolicyDefaultsPlugin = (
+  options: PolicyDefaultsOptions = {},
+) => ({
+  name: POLICY_DEFAULTS_PLUGIN_NAME,
+  setup(api: PolicyDefaultsPluginApi) {
+    applyPolicyDefaults(api, options);
+  },
+});

package/src/runtime-package-resolution.ts

@@ -0,0 +1,115 @@
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { RsbuildPlugin, Rspack } from '@rsbuild/core';
+
+/**
+ * A generated `runtime-register.js` lives inside the *application*, so every
+ * runtime plugin it imports has to resolve from the application's own
+ * `node_modules`. Packages registered by a CLI plugin are dependencies of that
+ * CLI plugin, not of the application, and under an isolated (pnpm) linker the
+ * application cannot see them — the build fails with `Module not found`.
+ *
+ * Instead of freezing a single resolved file (which would lock one export
+ * condition and break the web/node split), the registering package contributes
+ * the `node_modules` directory that actually hosts the package as a *fallback*
+ * module directory. Bare specifiers keep their normal `exports` resolution, the
+ * application's own copy still wins when it declares the dependency, and both
+ * the workspace source layout and a published pnpm layout work.
+ */
+export const findHostingModuleDirectory = (
+  packageName: string,
+  fromDirectory: string,
+): string | undefined => {
+  let directory = path.resolve(fromDirectory);
+  for (;;) {
+    const candidate = path.join(directory, 'node_modules');
+    if (fs.existsSync(path.join(candidate, packageName))) {
+      return candidate;
+    }
+    const parent = path.dirname(directory);
+    if (parent === directory) {
+      return undefined;
+    }
+    directory = parent;
+  }
+};
+
+/**
+ * Collect the fallback module directories for the given packages, starting the
+ * search at the module that registers them.
+ */
+export const collectRuntimePackageModuleDirectories = (
+  packageNames: readonly string[],
+  registrarUrl: string,
+): string[] => {
+  const registrarDirectory = path.dirname(fileURLToPath(registrarUrl));
+  const directories: string[] = [];
+  for (const packageName of packageNames) {
+    const directory = findHostingModuleDirectory(
+      packageName,
+      registrarDirectory,
+    );
+    if (directory && !directories.includes(directory)) {
+      directories.push(directory);
+    }
+  }
+  return directories;
+};
+
+const appendModuleDirectories = (
+  config: Rspack.Configuration,
+  directories: readonly string[],
+) => {
+  if (directories.length === 0) {
+    return;
+  }
+  config.resolve ??= {};
+  const existing = config.resolve.modules ?? ['node_modules'];
+  // Appended, never prepended: the application's own upward `node_modules`
+  // search keeps priority, so a declared dependency still wins.
+  config.resolve.modules = [
+    ...existing,
+    ...directories.filter(directory => !existing.includes(directory)),
+  ];
+};
+
+/**
+ * Rsbuild plugin that adds the given directories as fallback module roots for
+ * every environment (web, node and worker bundles alike).
+ */
+export const createRuntimePackageResolutionPlugin = (
+  directories: readonly string[],
+): RsbuildPlugin => ({
+  name: 'ultramodern:runtime-package-resolution',
+  setup(api) {
+    api.modifyRspackConfig({
+      order: 'post',
+      handler(config) {
+        appendModuleDirectories(config, directories);
+      },
+    });
+    api.onBeforeCreateCompiler({
+      order: 'post',
+      handler({ bundlerConfigs }) {
+        for (const config of bundlerConfigs) {
+          appendModuleDirectories(config, directories);
+        }
+      },
+    });
+  },
+});
+
+/** `true` when the package resolves from the registering module at all. */
+export const canResolveRuntimePackage = (
+  packageName: string,
+  registrarUrl: string,
+): boolean => {
+  try {
+    createRequire(registrarUrl).resolve(packageName);
+    return true;
+  } catch {
+    return false;
+  }
+};