@bleedingdev/modern-js-plugin 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

package/dist/cjs/cli/index.js

@@ -29,29 +29,42 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     cli: ()=>index_js_namespaceObject.cli,
+    createAsyncHook: ()=>external_hooks_js_namespaceObject.createAsyncHook,
+    createAsyncInterruptHook: ()=>external_hooks_js_namespaceObject.createAsyncInterruptHook,
+    createAsyncPipelineHook: ()=>external_hooks_js_namespaceObject.createAsyncPipelineHook,
     createCli: ()=>index_js_namespaceObject.createCli,
+    createCollectAsyncHook: ()=>external_hooks_js_namespaceObject.createCollectAsyncHook,
+    createCollectSyncHook: ()=>external_hooks_js_namespaceObject.createCollectSyncHook,
     createConfigOptions: ()=>create_js_namespaceObject.createConfigOptions,
     createContext: ()=>external_context_js_namespaceObject.createContext,
     createLoadedConfig: ()=>index_js_namespaceObject.createLoadedConfig,
     createStorybookOptions: ()=>create_js_namespaceObject.createStorybookOptions,
+    createSyncHook: ()=>external_hooks_js_namespaceObject.createSyncHook,
     initAppContext: ()=>external_context_js_namespaceObject.initAppContext,
     initAppDir: ()=>index_js_namespaceObject.initAppDir,
-    initHooks: ()=>external_hooks_js_namespaceObject.initHooks,
+    initHooks: ()=>external_hooks_js_namespaceObject_1.initHooks,
     initPluginAPI: ()=>external_api_js_namespaceObject.initPluginAPI,
     mergeConfig: ()=>mergeConfig_js_namespaceObject.mergeConfig
 });
+const external_hooks_js_namespaceObject = require("../hooks.js");
 const external_api_js_namespaceObject = require("./api.js");
 const external_context_js_namespaceObject = require("./context.js");
-const external_hooks_js_namespaceObject = require("./hooks.js");
+const external_hooks_js_namespaceObject_1 = require("./hooks.js");
 const index_js_namespaceObject = require("./run/index.js");
 const create_js_namespaceObject = require("./run/create.js");
 const mergeConfig_js_namespaceObject = require("./run/utils/mergeConfig.js");
 exports.cli = __webpack_exports__.cli;
+exports.createAsyncHook = __webpack_exports__.createAsyncHook;
+exports.createAsyncInterruptHook = __webpack_exports__.createAsyncInterruptHook;
+exports.createAsyncPipelineHook = __webpack_exports__.createAsyncPipelineHook;
 exports.createCli = __webpack_exports__.createCli;
+exports.createCollectAsyncHook = __webpack_exports__.createCollectAsyncHook;
+exports.createCollectSyncHook = __webpack_exports__.createCollectSyncHook;
 exports.createConfigOptions = __webpack_exports__.createConfigOptions;
 exports.createContext = __webpack_exports__.createContext;
 exports.createLoadedConfig = __webpack_exports__.createLoadedConfig;
 exports.createStorybookOptions = __webpack_exports__.createStorybookOptions;
+exports.createSyncHook = __webpack_exports__.createSyncHook;
 exports.initAppContext = __webpack_exports__.initAppContext;
 exports.initAppDir = __webpack_exports__.initAppDir;
 exports.initHooks = __webpack_exports__.initHooks;
@@ -59,11 +72,17 @@ exports.initPluginAPI = __webpack_exports__.initPluginAPI;
 exports.mergeConfig = __webpack_exports__.mergeConfig;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "cli",
+    "createAsyncHook",
+    "createAsyncInterruptHook",
+    "createAsyncPipelineHook",
     "createCli",
+    "createCollectAsyncHook",
+    "createCollectSyncHook",
     "createConfigOptions",
     "createContext",
     "createLoadedConfig",
     "createStorybookOptions",
+    "createSyncHook",
     "initAppContext",
     "initAppDir",
     "initHooks",

package/dist/cjs/cli/run/config/createLoadedConfig.js

@@ -33,14 +33,16 @@ __webpack_require__.d(__webpack_exports__, {
 const utils_namespaceObject = require("@modern-js/utils");
 const mergeConfig_js_namespaceObject = require("../utils/mergeConfig.js");
 const external_loadConfig_js_namespaceObject = require("./loadConfig.js");
-async function getConfigObject(config) {
-    if ('function' == typeof config) return await config({
+async function getConfigObject(config, context) {
+    if ('function' == typeof config) return await config(context ? {
+        ...context
+    } : {
         env: (0, utils_namespaceObject.getNodeEnv)(),
         command: (0, utils_namespaceObject.getCommand)()
     }) || {};
     return config || {};
 }
-async function loadLocalConfig(appDirectory, configFile) {
+async function loadLocalConfig(appDirectory, configFile, context) {
     let localConfigFile = false;
     if ('string' == typeof configFile) {
         for (const ext of utils_namespaceObject.CONFIG_FILE_EXTENSIONS)if (configFile.endsWith(ext)) {
@@ -50,21 +52,28 @@ async function loadLocalConfig(appDirectory, configFile) {
     }
     if (localConfigFile) {
         const loaded = await (0, external_loadConfig_js_namespaceObject.loadConfig)(appDirectory, localConfigFile);
-        return getConfigObject(loaded.config);
+        return getConfigObject(loaded.config, context);
     }
     return null;
 }
-async function createLoadedConfig(appDirectory, configFilePath, otherConfig) {
+async function createLoadedConfig(appDirectory, configFilePath, otherConfig, context) {
+    const evaluationContext = context ? {
+        ...context
+    } : void 0;
+    const shouldLoadLocal = evaluationContext ? [
+        'dev',
+        'start'
+    ].includes(evaluationContext.command) : void 0;
     const configFile = (0, external_loadConfig_js_namespaceObject.getConfigFilePath)(appDirectory, configFilePath);
     const loaded = await (0, external_loadConfig_js_namespaceObject.loadConfig)(appDirectory, configFile);
     if (!loaded.config && !loaded.pkgConfig) {
         utils_namespaceObject.logger.warn("Can not find any config file in the current project, please check if you have a correct config file.");
         utils_namespaceObject.logger.warn(`Current project path: ${utils_namespaceObject.chalk.yellow(appDirectory)}`);
     }
-    const config = await getConfigObject(loaded.config);
+    const config = await getConfigObject(loaded.config, evaluationContext);
     let mergedConfig = config;
-    if ((0, utils_namespaceObject.isDevCommand)()) {
-        const localConfig = await loadLocalConfig(appDirectory, configFile);
+    if (shouldLoadLocal ?? (0, utils_namespaceObject.isDevCommand)()) {
+        const localConfig = await loadLocalConfig(appDirectory, configFile, evaluationContext);
         if (localConfig) mergedConfig = (0, mergeConfig_js_namespaceObject.mergeConfig)([
             mergedConfig,
             localConfig

package/dist/cjs/cli/run/create.js

@@ -135,15 +135,20 @@ const createCli = ()=>{
     async function run(options) {
         const { appContext } = await init(options);
         await appContext.hooks.addCommand.call({
-            program: commander_namespaceObject.program
+            program: (0, commander_js_namespaceObject.initCommandsMap)()
         });
         await (0, createFileWatcher_js_namespaceObject.createFileWatcher)(appContext);
         commander_namespaceObject.program.parse(process.argv);
         if (!commander_namespaceObject.program.commands?.length) utils_namespaceObject.logger.warn('No command found, please make sure you have registered plugins correctly.');
     }
+    function dispose() {
+        for (const [event, listener] of existListenerMap)process.off(event, listener);
+        existListenerMap.clear();
+    }
     return {
         init,
         run,
+        dispose,
         getPrevInitOptions: ()=>initOptions
     };
 };

package/dist/cjs/cli/run/utils/commander.js

@@ -29,23 +29,25 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     initCommandsMap: ()=>initCommandsMap,
-    program: ()=>utils_namespaceObject.program,
+    program: ()=>commander_namespaceObject.program,
     setProgramVersion: ()=>setProgramVersion
 });
-const utils_namespaceObject = require("@modern-js/utils");
+const commander_namespaceObject = require("@modern-js/utils/commander");
 const setProgramVersion = (version = 'unknown')=>{
     const name = process.argv[1];
-    utils_namespaceObject.program.name(name).usage('<command> [options]').version(version);
+    commander_namespaceObject.program.name(name).usage('<command> [options]');
+    if (commander_namespaceObject.program.version() !== version) commander_namespaceObject.program.version(version);
 };
 function initCommandsMap() {
-    if (!utils_namespaceObject.program.hasOwnProperty('commandsMap')) Object.defineProperty(utils_namespaceObject.program, 'commandsMap', {
+    if (!commander_namespaceObject.program.hasOwnProperty('commandsMap')) Object.defineProperty(commander_namespaceObject.program, 'commandsMap', {
         get () {
             const map = new Map();
-            for (const command of utils_namespaceObject.program.commands)map.set(command._name, command);
+            for (const command of commander_namespaceObject.program.commands)map.set(command._name, command);
             return map;
         },
         configurable: false
     });
+    return commander_namespaceObject.program;
 }
 exports.initCommandsMap = __webpack_exports__.initCommandsMap;
 exports.program = __webpack_exports__.program;

package/dist/cjs/cli/run/utils/debug.js

@@ -30,8 +30,8 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     debug: ()=>debug
 });
-const utils_namespaceObject = require("@modern-js/utils");
-const debug = (0, utils_namespaceObject.createDebugger)('plugin');
+const cli_common_namespaceObject = require("@modern-js/utils/cli-common");
+const debug = (0, cli_common_namespaceObject.createDebugger)('plugin');
 exports.debug = __webpack_exports__.debug;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "debug"

package/dist/cjs/runtime/api.js

@@ -73,6 +73,8 @@ function initPluginAPI({ context, plugins }) {
         getRuntimeConfig,
         config: hooks.config.tap,
         onBeforeRender: hooks.onBeforeRender.tap,
+        onRenderPrepared: hooks.onRenderPrepared.tap,
+        onRequestEnd: hooks.onRequestEnd.tap,
         wrapRoot: hooks.wrapRoot.tap,
         resolveComponent: hooks.resolveComponent.tap,
         pickContext: hooks.pickContext.tap,

package/dist/cjs/runtime/hooks.js

@@ -32,8 +32,24 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_hooks_js_namespaceObject = require("../hooks.js");
 function initHooks() {
+    const requestEnd = (0, external_hooks_js_namespaceObject.createCollectSyncHook)();
+    const onRequestEnd = {
+        tap (callback) {
+            requestEnd.tap((info)=>Promise.resolve().then(()=>callback(info)));
+        },
+        async call (info) {
+            const results = await Promise.allSettled(requestEnd.call(info));
+            const errors = results.flatMap((result)=>'rejected' === result.status ? [
+                    result.reason
+                ] : []);
+            if (1 === errors.length) throw errors[0];
+            if (errors.length > 1) throw new AggregateError(errors, 'Request completion hooks failed');
+        }
+    };
     return {
         onBeforeRender: (0, external_hooks_js_namespaceObject.createAsyncInterruptHook)(),
+        onRenderPrepared: (0, external_hooks_js_namespaceObject.createAsyncHook)(),
+        onRequestEnd,
         wrapRoot: (0, external_hooks_js_namespaceObject.createSyncHook)(),
         resolveComponent: (0, external_hooks_js_namespaceObject.createSyncHook)(),
         pickContext: (0, external_hooks_js_namespaceObject.createSyncHook)(),

package/dist/cjs/server/api.js

@@ -31,9 +31,9 @@ __webpack_require__.d(__webpack_exports__, {
     debug: ()=>debug,
     initPluginAPI: ()=>initPluginAPI
 });
-const utils_namespaceObject = require("@modern-js/utils");
+const cli_common_namespaceObject = require("@modern-js/utils/cli-common");
 const lodash_namespaceObject = require("@modern-js/utils/lodash");
-const debug = (0, utils_namespaceObject.createDebugger)('plugin-server-v2');
+const debug = (0, cli_common_namespaceObject.createDebugger)('plugin-server-v2');
 function initPluginAPI({ context, pluginManager }) {
     const { hooks, extendsHooks, plugins } = context;
     function getServerContext() {

package/dist/esm/cli/index.mjs

@@ -1,3 +1,4 @@
+export { createAsyncHook, createAsyncInterruptHook, createAsyncPipelineHook, createCollectAsyncHook, createCollectSyncHook, createSyncHook } from "../hooks.mjs";
 export { initPluginAPI } from "./api.mjs";
 export { createContext, initAppContext } from "./context.mjs";
 export { initHooks } from "./hooks.mjs";

package/dist/esm/cli/run/config/createLoadedConfig.mjs

@@ -1,14 +1,16 @@
 import { CONFIG_FILE_EXTENSIONS, chalk, fs, getCommand, getNodeEnv, isDevCommand, logger } from "@modern-js/utils";
 import { mergeConfig } from "../utils/mergeConfig.mjs";
 import { getConfigFilePath, loadConfig } from "./loadConfig.mjs";
-async function getConfigObject(config) {
-    if ('function' == typeof config) return await config({
+async function getConfigObject(config, context) {
+    if ('function' == typeof config) return await config(context ? {
+        ...context
+    } : {
         env: getNodeEnv(),
         command: getCommand()
     }) || {};
     return config || {};
 }
-async function loadLocalConfig(appDirectory, configFile) {
+async function loadLocalConfig(appDirectory, configFile, context) {
     let localConfigFile = false;
     if ('string' == typeof configFile) {
         for (const ext of CONFIG_FILE_EXTENSIONS)if (configFile.endsWith(ext)) {
@@ -18,21 +20,28 @@ async function loadLocalConfig(appDirectory, configFile) {
     }
     if (localConfigFile) {
         const loaded = await loadConfig(appDirectory, localConfigFile);
-        return getConfigObject(loaded.config);
+        return getConfigObject(loaded.config, context);
     }
     return null;
 }
-async function createLoadedConfig(appDirectory, configFilePath, otherConfig) {
+async function createLoadedConfig(appDirectory, configFilePath, otherConfig, context) {
+    const evaluationContext = context ? {
+        ...context
+    } : void 0;
+    const shouldLoadLocal = evaluationContext ? [
+        'dev',
+        'start'
+    ].includes(evaluationContext.command) : void 0;
     const configFile = getConfigFilePath(appDirectory, configFilePath);
     const loaded = await loadConfig(appDirectory, configFile);
     if (!loaded.config && !loaded.pkgConfig) {
         logger.warn("Can not find any config file in the current project, please check if you have a correct config file.");
         logger.warn(`Current project path: ${chalk.yellow(appDirectory)}`);
     }
-    const config = await getConfigObject(loaded.config);
+    const config = await getConfigObject(loaded.config, evaluationContext);
     let mergedConfig = config;
-    if (isDevCommand()) {
-        const localConfig = await loadLocalConfig(appDirectory, configFile);
+    if (shouldLoadLocal ?? isDevCommand()) {
+        const localConfig = await loadLocalConfig(appDirectory, configFile, evaluationContext);
         if (localConfig) mergedConfig = mergeConfig([
             mergedConfig,
             localConfig

package/dist/esm/cli/run/create.mjs

@@ -101,15 +101,20 @@ const createCli = ()=>{
     async function run(options) {
         const { appContext } = await init(options);
         await appContext.hooks.addCommand.call({
-            program: program
+            program: initCommandsMap()
         });
         await createFileWatcher(appContext);
         program.parse(process.argv);
         if (!program.commands?.length) logger.warn('No command found, please make sure you have registered plugins correctly.');
     }
+    function dispose() {
+        for (const [event, listener] of existListenerMap)process.off(event, listener);
+        existListenerMap.clear();
+    }
     return {
         init,
         run,
+        dispose,
         getPrevInitOptions: ()=>initOptions
     };
 };

package/dist/esm/cli/run/utils/commander.mjs

@@ -1,7 +1,8 @@
-import { program } from "@modern-js/utils";
+import { program } from "@modern-js/utils/commander";
 const setProgramVersion = (version = 'unknown')=>{
     const name = process.argv[1];
-    program.name(name).usage('<command> [options]').version(version);
+    program.name(name).usage('<command> [options]');
+    if (program.version() !== version) program.version(version);
 };
 function initCommandsMap() {
     if (!program.hasOwnProperty('commandsMap')) Object.defineProperty(program, 'commandsMap', {
@@ -12,5 +13,6 @@ function initCommandsMap() {
         },
         configurable: false
     });
+    return program;
 }
 export { initCommandsMap, program, setProgramVersion };

package/dist/esm/cli/run/utils/debug.mjs

@@ -1,3 +1,3 @@
-import { createDebugger } from "@modern-js/utils";
+import { createDebugger } from "@modern-js/utils/cli-common";
 const debug = createDebugger('plugin');
 export { debug };

package/dist/esm/runtime/api.mjs

@@ -41,6 +41,8 @@ function initPluginAPI({ context, plugins }) {
         getRuntimeConfig,
         config: hooks.config.tap,
         onBeforeRender: hooks.onBeforeRender.tap,
+        onRenderPrepared: hooks.onRenderPrepared.tap,
+        onRequestEnd: hooks.onRequestEnd.tap,
         wrapRoot: hooks.wrapRoot.tap,
         resolveComponent: hooks.resolveComponent.tap,
         pickContext: hooks.pickContext.tap,

package/dist/esm/runtime/hooks.mjs

@@ -1,7 +1,23 @@
-import { createAsyncInterruptHook, createCollectSyncHook, createSyncHook } from "../hooks.mjs";
+import { createAsyncHook, createAsyncInterruptHook, createCollectSyncHook, createSyncHook } from "../hooks.mjs";
 function initHooks() {
+    const requestEnd = createCollectSyncHook();
+    const onRequestEnd = {
+        tap (callback) {
+            requestEnd.tap((info)=>Promise.resolve().then(()=>callback(info)));
+        },
+        async call (info) {
+            const results = await Promise.allSettled(requestEnd.call(info));
+            const errors = results.flatMap((result)=>'rejected' === result.status ? [
+                    result.reason
+                ] : []);
+            if (1 === errors.length) throw errors[0];
+            if (errors.length > 1) throw new AggregateError(errors, 'Request completion hooks failed');
+        }
+    };
     return {
         onBeforeRender: createAsyncInterruptHook(),
+        onRenderPrepared: createAsyncHook(),
+        onRequestEnd,
         wrapRoot: createSyncHook(),
         resolveComponent: createSyncHook(),
         pickContext: createSyncHook(),

package/dist/esm/server/api.mjs

@@ -1,4 +1,4 @@
-import { createDebugger } from "@modern-js/utils";
+import { createDebugger } from "@modern-js/utils/cli-common";
 import { assign as lodash_assign } from "@modern-js/utils/lodash";
 const debug = createDebugger('plugin-server-v2');
 function initPluginAPI({ context, pluginManager }) {

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

@@ -1,4 +1,5 @@
 import "node:module";
+export { createAsyncHook, createAsyncInterruptHook, createAsyncPipelineHook, createCollectAsyncHook, createCollectSyncHook, createSyncHook } from "../hooks.mjs";
 export { initPluginAPI } from "./api.mjs";
 export { createContext, initAppContext } from "./context.mjs";
 export { initHooks } from "./hooks.mjs";

package/dist/esm-node/cli/run/config/createLoadedConfig.mjs

@@ -2,14 +2,16 @@ import "node:module";
 import { CONFIG_FILE_EXTENSIONS, chalk, fs, getCommand, getNodeEnv, isDevCommand, logger } from "@modern-js/utils";
 import { mergeConfig } from "../utils/mergeConfig.mjs";
 import { getConfigFilePath, loadConfig } from "./loadConfig.mjs";
-async function getConfigObject(config) {
-    if ('function' == typeof config) return await config({
+async function getConfigObject(config, context) {
+    if ('function' == typeof config) return await config(context ? {
+        ...context
+    } : {
         env: getNodeEnv(),
         command: getCommand()
     }) || {};
     return config || {};
 }
-async function loadLocalConfig(appDirectory, configFile) {
+async function loadLocalConfig(appDirectory, configFile, context) {
     let localConfigFile = false;
     if ('string' == typeof configFile) {
         for (const ext of CONFIG_FILE_EXTENSIONS)if (configFile.endsWith(ext)) {
@@ -19,21 +21,28 @@ async function loadLocalConfig(appDirectory, configFile) {
     }
     if (localConfigFile) {
         const loaded = await loadConfig(appDirectory, localConfigFile);
-        return getConfigObject(loaded.config);
+        return getConfigObject(loaded.config, context);
     }
     return null;
 }
-async function createLoadedConfig(appDirectory, configFilePath, otherConfig) {
+async function createLoadedConfig(appDirectory, configFilePath, otherConfig, context) {
+    const evaluationContext = context ? {
+        ...context
+    } : void 0;
+    const shouldLoadLocal = evaluationContext ? [
+        'dev',
+        'start'
+    ].includes(evaluationContext.command) : void 0;
     const configFile = getConfigFilePath(appDirectory, configFilePath);
     const loaded = await loadConfig(appDirectory, configFile);
     if (!loaded.config && !loaded.pkgConfig) {
         logger.warn("Can not find any config file in the current project, please check if you have a correct config file.");
         logger.warn(`Current project path: ${chalk.yellow(appDirectory)}`);
     }
-    const config = await getConfigObject(loaded.config);
+    const config = await getConfigObject(loaded.config, evaluationContext);
     let mergedConfig = config;
-    if (isDevCommand()) {
-        const localConfig = await loadLocalConfig(appDirectory, configFile);
+    if (shouldLoadLocal ?? isDevCommand()) {
+        const localConfig = await loadLocalConfig(appDirectory, configFile, evaluationContext);
         if (localConfig) mergedConfig = mergeConfig([
             mergedConfig,
             localConfig

package/dist/esm-node/cli/run/create.mjs

@@ -102,15 +102,20 @@ const createCli = ()=>{
     async function run(options) {
         const { appContext } = await init(options);
         await appContext.hooks.addCommand.call({
-            program: program
+            program: initCommandsMap()
         });
         await createFileWatcher(appContext);
         program.parse(process.argv);
         if (!program.commands?.length) logger.warn('No command found, please make sure you have registered plugins correctly.');
     }
+    function dispose() {
+        for (const [event, listener] of existListenerMap)process.off(event, listener);
+        existListenerMap.clear();
+    }
     return {
         init,
         run,
+        dispose,
         getPrevInitOptions: ()=>initOptions
     };
 };

package/dist/esm-node/cli/run/utils/commander.mjs

@@ -1,8 +1,9 @@
 import "node:module";
-import { program } from "@modern-js/utils";
+import { program } from "@modern-js/utils/commander";
 const setProgramVersion = (version = 'unknown')=>{
     const name = process.argv[1];
-    program.name(name).usage('<command> [options]').version(version);
+    program.name(name).usage('<command> [options]');
+    if (program.version() !== version) program.version(version);
 };
 function initCommandsMap() {
     if (!program.hasOwnProperty('commandsMap')) Object.defineProperty(program, 'commandsMap', {
@@ -13,5 +14,6 @@ function initCommandsMap() {
         },
         configurable: false
     });
+    return program;
 }
 export { initCommandsMap, program, setProgramVersion };

package/dist/esm-node/cli/run/utils/debug.mjs

@@ -1,4 +1,4 @@
 import "node:module";
-import { createDebugger } from "@modern-js/utils";
+import { createDebugger } from "@modern-js/utils/cli-common";
 const debug = createDebugger('plugin');
 export { debug };

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

@@ -42,6 +42,8 @@ function initPluginAPI({ context, plugins }) {
         getRuntimeConfig,
         config: hooks.config.tap,
         onBeforeRender: hooks.onBeforeRender.tap,
+        onRenderPrepared: hooks.onRenderPrepared.tap,
+        onRequestEnd: hooks.onRequestEnd.tap,
         wrapRoot: hooks.wrapRoot.tap,
         resolveComponent: hooks.resolveComponent.tap,
         pickContext: hooks.pickContext.tap,

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

@@ -1,8 +1,24 @@
 import "node:module";
-import { createAsyncInterruptHook, createCollectSyncHook, createSyncHook } from "../hooks.mjs";
+import { createAsyncHook, createAsyncInterruptHook, createCollectSyncHook, createSyncHook } from "../hooks.mjs";
 function initHooks() {
+    const requestEnd = createCollectSyncHook();
+    const onRequestEnd = {
+        tap (callback) {
+            requestEnd.tap((info)=>Promise.resolve().then(()=>callback(info)));
+        },
+        async call (info) {
+            const results = await Promise.allSettled(requestEnd.call(info));
+            const errors = results.flatMap((result)=>'rejected' === result.status ? [
+                    result.reason
+                ] : []);
+            if (1 === errors.length) throw errors[0];
+            if (errors.length > 1) throw new AggregateError(errors, 'Request completion hooks failed');
+        }
+    };
     return {
         onBeforeRender: createAsyncInterruptHook(),
+        onRenderPrepared: createAsyncHook(),
+        onRequestEnd,
         wrapRoot: createSyncHook(),
         resolveComponent: createSyncHook(),
         pickContext: createSyncHook(),

package/dist/esm-node/server/api.mjs

@@ -1,5 +1,5 @@
 import "node:module";
-import { createDebugger } from "@modern-js/utils";
+import { createDebugger } from "@modern-js/utils/cli-common";
 import { assign as lodash_assign } from "@modern-js/utils/lodash";
 const debug = createDebugger('plugin-server-v2');
 function initPluginAPI({ context, pluginManager }) {

package/dist/types/cli/api.d.ts

@@ -4,5 +4,5 @@ import type { CLIPluginExtends } from '../types/cli/plugin.js';
 import type { PluginManager } from '../types/plugin.js';
 export declare function initPluginAPI<Extends extends CLIPluginExtends>({ context, pluginManager, }: {
     context: InternalContext<Extends>;
-    pluginManager: PluginManager;
+    pluginManager: Pick<PluginManager, 'isPluginExists'>;
 }): CLIPluginAPI<Extends>;

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

@@ -1,42 +1,33 @@
 import type { OnAfterBuildFn, OnAfterCreateCompilerFn, OnBeforeBuildFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn } from '@rsbuild/core';
 import type { AddCommandFn, AddWatchFilesFn, ConfigFn, InternalRuntimePluginsFn, InternalServerPluginsFn, ModifyBundlerChainFn, ModifyConfigFn, ModifyHtmlPartialsFn, ModifyResolvedConfigFn, ModifyRsbuildConfigFn, ModifyRspackConfigFn, ModifyServerRoutesFn, OnAfterDeployFn, OnAfterDevFn, OnBeforeDeployFn, OnBeforeDevFn, OnBeforeExitFn, OnBeforeRestartFn, OnFileChangedFn, OnPrepareFn, RuntimePluginConfig, ServerPluginConfig } from '../types/cli/hooks.js';
+import type { AsyncHook, CollectAsyncHook } from '../types/hooks.js';
 import type { DeepPartial } from '../types/utils.js';
 export type { AddCommandFn, AddWatchFilesFn, ConfigFn, InternalRuntimePluginsFn, InternalServerPluginsFn, ModifyBundlerChainFn, ModifyConfigFn, ModifyHtmlPartialsFn, ModifyResolvedConfigFn, ModifyRsbuildConfigFn, ModifyRspackConfigFn, ModifyServerRoutesFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterDeployFn, OnAfterDevFn, OnBeforeBuildFn, OnBeforeCreateCompilerFn, OnBeforeDeployFn, OnBeforeDevFn, OnBeforeExitFn, OnBeforeRestartFn, OnDevCompileDoneFn, OnFileChangedFn, OnPrepareFn, RuntimePluginConfig, ServerPluginConfig, };
-export declare function initHooks<Config, NormalizedConfig, ExtendBuildUtils, ExtendConfigUtils>(): {
-    /**
-     * add config for this cli plugin
-     */
-    config: import("../index.js").CollectAsyncHook<ConfigFn<DeepPartial<Config>>>;
-    /**
-     * @private
-     * modify config for this cli plugin
-     */
-    modifyConfig: import("../index.js").AsyncHook<ModifyConfigFn<Config, ExtendConfigUtils>>;
-    /**
-     * modify final config
-     */
-    modifyResolvedConfig: import("../index.js").AsyncHook<ModifyResolvedConfigFn<NormalizedConfig, ExtendConfigUtils>>;
-    modifyRsbuildConfig: import("../index.js").AsyncHook<ModifyRsbuildConfigFn<ExtendBuildUtils>>;
-    modifyBundlerChain: import("../index.js").AsyncHook<ModifyBundlerChainFn<ExtendBuildUtils>>;
-    modifyRspackConfig: import("../index.js").AsyncHook<ModifyRspackConfigFn<ExtendBuildUtils>>;
-    modifyHtmlPartials: import("../index.js").AsyncHook<ModifyHtmlPartialsFn>;
-    addCommand: import("../index.js").AsyncHook<AddCommandFn>;
-    addWatchFiles: import("../index.js").CollectAsyncHook<AddWatchFilesFn>;
-    onPrepare: import("../index.js").AsyncHook<OnPrepareFn>;
-    onFileChanged: import("../index.js").AsyncHook<OnFileChangedFn>;
-    onBeforeRestart: import("../index.js").AsyncHook<OnBeforeRestartFn>;
-    onBeforeCreateCompiler: import("../index.js").AsyncHook<OnBeforeCreateCompilerFn>;
-    onAfterCreateCompiler: import("../index.js").AsyncHook<OnAfterCreateCompilerFn>;
-    onDevCompileDone: import("../index.js").AsyncHook<import("@rsbuild/core").OnAfterDevCompileFn>;
-    onBeforeBuild: import("../index.js").AsyncHook<OnBeforeBuildFn>;
-    onAfterBuild: import("../index.js").AsyncHook<OnAfterBuildFn>;
-    onBeforeDev: import("../index.js").AsyncHook<OnBeforeDevFn>;
-    onAfterDev: import("../index.js").AsyncHook<OnAfterDevFn>;
-    onBeforeDeploy: import("../index.js").AsyncHook<OnBeforeDeployFn>;
-    onAfterDeploy: import("../index.js").AsyncHook<OnAfterDeployFn>;
-    onBeforeExit: import("../index.js").AsyncHook<OnBeforeExitFn>;
-    _internalRuntimePlugins: import("../index.js").AsyncHook<InternalRuntimePluginsFn>;
-    _internalServerPlugins: import("../index.js").AsyncHook<InternalServerPluginsFn>;
-    modifyServerRoutes: import("../index.js").AsyncHook<ModifyServerRoutesFn>;
+export declare function initHooks<Config, NormalizedConfig, ExtendBuildUtils, ExtendConfigUtils>(): Hooks<Config, NormalizedConfig, ExtendBuildUtils, ExtendConfigUtils>;
+export type Hooks<Config, NormalizedConfig, ExtendBuildUtils, ExtendConfigUtils> = {
+    config: CollectAsyncHook<ConfigFn<DeepPartial<Config>>>;
+    modifyConfig: AsyncHook<ModifyConfigFn<Config, ExtendConfigUtils>>;
+    modifyResolvedConfig: AsyncHook<ModifyResolvedConfigFn<NormalizedConfig, ExtendConfigUtils>>;
+    modifyRsbuildConfig: AsyncHook<ModifyRsbuildConfigFn<ExtendBuildUtils>>;
+    modifyBundlerChain: AsyncHook<ModifyBundlerChainFn<ExtendBuildUtils>>;
+    modifyRspackConfig: AsyncHook<ModifyRspackConfigFn<ExtendBuildUtils>>;
+    modifyHtmlPartials: AsyncHook<ModifyHtmlPartialsFn>;
+    addCommand: AsyncHook<AddCommandFn>;
+    addWatchFiles: CollectAsyncHook<AddWatchFilesFn>;
+    onPrepare: AsyncHook<OnPrepareFn>;
+    onFileChanged: AsyncHook<OnFileChangedFn>;
+    onBeforeRestart: AsyncHook<OnBeforeRestartFn>;
+    onBeforeCreateCompiler: AsyncHook<OnBeforeCreateCompilerFn>;
+    onAfterCreateCompiler: AsyncHook<OnAfterCreateCompilerFn>;
+    onDevCompileDone: AsyncHook<OnDevCompileDoneFn>;
+    onBeforeBuild: AsyncHook<OnBeforeBuildFn>;
+    onAfterBuild: AsyncHook<OnAfterBuildFn>;
+    onBeforeDev: AsyncHook<OnBeforeDevFn>;
+    onAfterDev: AsyncHook<OnAfterDevFn>;
+    onBeforeDeploy: AsyncHook<OnBeforeDeployFn>;
+    onAfterDeploy: AsyncHook<OnAfterDeployFn>;
+    onBeforeExit: AsyncHook<OnBeforeExitFn>;
+    _internalRuntimePlugins: AsyncHook<InternalRuntimePluginsFn>;
+    _internalServerPlugins: AsyncHook<InternalServerPluginsFn>;
+    modifyServerRoutes: AsyncHook<ModifyServerRoutesFn>;
 };
-export type Hooks<Config, NormalizedConfig, ExtendBuildUtils, ExtendConfigUtils> = ReturnType<typeof initHooks<Config, NormalizedConfig, ExtendBuildUtils, ExtendConfigUtils>>;

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

@@ -1,6 +1,12 @@
+export { createAsyncHook, createAsyncInterruptHook, createAsyncPipelineHook, createCollectAsyncHook, createCollectSyncHook, createSyncHook, } from '../hooks.js';
+export type { AppContext, CLIPlugin, CLIPluginAPI, CLIPluginExtends, Entrypoint, InternalContext, } from '../types/cli/index.js';
+export type { AsyncHook, AsyncInterruptHook, AsyncPipelineHook, CollectAsyncHook, CollectSyncHook, PluginHook, PluginHookTap, SyncHook, } from '../types/hooks.js';
+export type { Plugin, PluginManager, TransformFunction, } from '../types/plugin.js';
 export { initPluginAPI } from './api.js';
 export { createContext, initAppContext } from './context.js';
 export { type AddCommandFn, type AddWatchFilesFn, type ConfigFn, type Hooks, type InternalRuntimePluginsFn, type InternalServerPluginsFn, initHooks, type ModifyBundlerChainFn, type ModifyConfigFn, type ModifyHtmlPartialsFn, type ModifyResolvedConfigFn, type ModifyRsbuildConfigFn, type ModifyRspackConfigFn, type ModifyServerRoutesFn, type OnAfterBuildFn, type OnAfterCreateCompilerFn, type OnAfterDeployFn, type OnAfterDevFn, type OnBeforeBuildFn, type OnBeforeCreateCompilerFn, type OnBeforeDeployFn, type OnBeforeDevFn, type OnBeforeExitFn, type OnBeforeRestartFn, type OnDevCompileDoneFn, type OnFileChangedFn, type OnPrepareFn, type RuntimePluginConfig, type ServerPluginConfig, } from './hooks.js';
 export { cli, createCli, createLoadedConfig, initAppDir } from './run/index.js';
+export type { ConfigEvaluationContext } from './run/config/createLoadedConfig.js';
 export { createConfigOptions, createStorybookOptions } from './run/create.js';
+export type { CLIOptions, CLIRunOptions, LoadedConfig } from './run/types.js';
 export { mergeConfig } from './run/utils/mergeConfig.js';

package/dist/types/cli/run/config/createLoadedConfig.d.ts

@@ -1,2 +1,6 @@
 import type { LoadedConfig } from '../types.js';
-export declare function createLoadedConfig<T>(appDirectory: string, configFilePath: string | false, otherConfig?: T): Promise<LoadedConfig<T>>;
+export interface ConfigEvaluationContext {
+    env: string;
+    command: string;
+}
+export declare function createLoadedConfig<T>(appDirectory: string, configFilePath: string | false, otherConfig?: T, context?: ConfigEvaluationContext): Promise<LoadedConfig<T>>;

package/dist/types/cli/run/create.d.ts

@@ -1,4 +1,4 @@
-import type { InternalContext } from '../../types/cli/context.js';
+import type { AppContext, InternalContext } from '../../types/cli/context.js';
 import type { CLIPluginExtends } from '../../types/cli/plugin.js';
 import type { CLIRunOptions } from './types.js';
 export declare const createCli: <Extends extends CLIPluginExtends>() => {
@@ -6,6 +6,7 @@ export declare const createCli: <Extends extends CLIPluginExtends>() => {
         appContext: InternalContext<Extends>;
     }>;
     run: (options: CLIRunOptions<Extends>) => Promise<void>;
+    dispose: () => void;
     getPrevInitOptions: () => CLIRunOptions<Extends>;
 };
 type UselessOptions = 'handleSetupResult' | 'command';
@@ -15,10 +16,10 @@ type CreateConfigOption<Extends extends CLIPluginExtends> = Omit<CLIRunOptions<E
 };
 export declare const createConfigOptions: <Extends extends CLIPluginExtends>(options: CreateConfigOption<Extends>) => Promise<{
     config: Awaited<Extends["normalizedConfig"]> | NonNullable<Awaited<import("../../types/utils.js").UnwrapPromise<Extends["normalizedConfig"]>>>;
-    getAppContext: () => Readonly<import("../../index.js").AppContext<Extends> & Extends["extendContext"]>;
+    getAppContext: () => Readonly<AppContext<Extends> & Extends["extendContext"]>;
 }>;
 export declare const createStorybookOptions: <Extends extends CLIPluginExtends>(options: Omit<CreateConfigOption<Extends>, 'command'>) => Promise<{
     config: Awaited<Extends["normalizedConfig"]> | NonNullable<Awaited<import("../../types/utils.js").UnwrapPromise<Extends["normalizedConfig"]>>>;
-    getAppContext: () => Readonly<import("../../index.js").AppContext<Extends> & Extends["extendContext"]>;
+    getAppContext: () => Readonly<AppContext<Extends> & Extends["extendContext"]>;
 }>;
 export {};

package/dist/types/cli/run/index.d.ts

@@ -5,9 +5,10 @@ export { run } from './run.js';
 export { initAppDir } from './utils/initAppDir.js';
 export { createCli };
 export declare const cli: {
-    init: (options: import("./types.js").CLIRunOptions<import("../../index.js").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>) => Promise<{
-        appContext: import("../../index.js").InternalContext<import("../../index.js").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>;
+    init: (options: import("./types.js").CLIRunOptions<import("../index.js").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>) => Promise<{
+        appContext: import("../index.js").InternalContext<import("../index.js").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>;
     }>;
-    run: (options: import("./types.js").CLIRunOptions<import("../../index.js").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>) => Promise<void>;
-    getPrevInitOptions: () => import("./types.js").CLIRunOptions<import("../../index.js").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>;
+    run: (options: import("./types.js").CLIRunOptions<import("../index.js").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>) => Promise<void>;
+    dispose: () => void;
+    getPrevInitOptions: () => import("./types.js").CLIRunOptions<import("../index.js").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>;
 };

package/dist/types/cli/run/types.d.ts

@@ -1,8 +1,5 @@
-import type { CLIPluginExtends } from '../../types/cli/index.js';
-import type { Plugin } from '../../types/plugin.js';
-export interface CLIOptions<Extends extends CLIPluginExtends = {
-    config: {};
-}> {
+import type { CLIPlugin, CLIPluginExtends } from '../../types/cli/index.js';
+export interface CLIOptions<Extends extends CLIPluginExtends = CLIPluginExtends> {
     cwd?: string;
     version?: string;
     metaName?: string;
@@ -15,7 +12,7 @@ export interface CLIOptions<Extends extends CLIPluginExtends = {
      */
     config?: Extends['config'];
     configFile: string | false;
-    internalPlugins?: Plugin[];
+    internalPlugins?: CLIPlugin<Extends>[];
     handleSetupResult?: (params: any, api: Record<string, any>) => Promise<void> | void;
 }
 export type LoadedConfig<T> = {
@@ -25,8 +22,6 @@ export type LoadedConfig<T> = {
     pkgConfig?: T;
     jsConfig?: T;
 };
-export interface CLIRunOptions<Extends extends CLIPluginExtends = {
-    config: {};
-}> extends CLIOptions<Extends> {
+export interface CLIRunOptions<Extends extends CLIPluginExtends = CLIPluginExtends> extends CLIOptions<Extends> {
     command: string;
 }

package/dist/types/cli/run/utils/commander.d.ts

@@ -1,5 +1,6 @@
-import { type Command, program } from '@modern-js/utils';
+import { type Command, program } from '@modern-js/utils/commander';
+import type { CliProgram } from '../../../types/cli/hooks.js';
 export declare const setProgramVersion: (version?: string) => void;
-export declare function initCommandsMap(): void;
+export declare function initCommandsMap(): CliProgram;
 export type { Command };
 export { program };

package/dist/types/cli/run/utils/createFileWatcher.d.ts

@@ -1,4 +1,5 @@
-import type { InternalContext } from '../../../types/index.js';
+import type { FSWatcher } from '@modern-js/utils/watch-options';
+import type { InternalContext } from '../../../types/cli/context.js';
 import type { CLIPluginExtends } from '../../../types/cli/plugin.js';
 /**
  * Editor temp files (e.g. `page.tsx.tmp.<pid>.<hash>`) can be created and
@@ -8,4 +9,4 @@ import type { CLIPluginExtends } from '../../../types/cli/plugin.js';
  * Treat a vanished file as "nothing to read" instead of rethrowing.
  */
 export declare const safeReadFileSync: (filePath: string) => string | undefined;
-export declare const createFileWatcher: <Extends extends CLIPluginExtends>(appContext: InternalContext<Extends>) => Promise<import("@modern-js/utils").FSWatcher | undefined>;
+export declare const createFileWatcher: <Extends extends CLIPluginExtends>(appContext: InternalContext<Extends>) => Promise<FSWatcher | undefined>;

package/dist/types/cli/run/utils/debug.d.ts

@@ -1,2 +1,2 @@
-import { createDebugger } from '@modern-js/utils';
+import { createDebugger } from '@modern-js/utils/cli-common';
 export declare const debug: ReturnType<typeof createDebugger>;

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
 export { createAsyncHook, createAsyncInterruptHook, createAsyncPipelineHook, createCollectAsyncHook, createCollectSyncHook, createSyncHook, } from './hooks.js';
 export { createPluginManager } from './manager.js';
-export type { AppContext, CLIPlugin, CLIPluginAPI, CLIPluginExtends, Entrypoint, InternalContext, RuntimePluginConfig, ServerPluginConfig, } from './types/cli/index.js';
+export type { AppContext, CLIPlugin, CLIPluginAPI, CLIPluginExtends, CliProgram, Entrypoint, InternalContext, RuntimePluginConfig, ServerPluginConfig, } from './types/cli/index.js';
 export type { AsyncHook, AsyncInterruptHook, AsyncPipelineHook, CollectAsyncHook, CollectSyncHook, PluginHook, PluginHookTap, SyncHook, } from './types/hooks.js';
 export type { Plugin, PluginManager, TransformFunction, } from './types/plugin.js';
 export type { InternalRuntimeContext, RuntimeContext, RuntimePlugin, RuntimePluginAPI, RuntimePluginExtends, } from './types/runtime/index.js';

package/dist/types/manager.d.ts

@@ -2,4 +2,4 @@
  * NOTE: This file will be used in both Node.js and runtime environments. Please avoid importing Node.js-specific APIs.
  */
 import type { PluginManager } from './types/plugin.js';
-export declare function createPluginManager(): PluginManager;
+export declare function createPluginManager<PluginAPI = {}, Context = {}>(): PluginManager<PluginAPI, Context>;

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

@@ -1,5 +1,5 @@
 export type { Hooks, InternalRuntimeContext, RuntimeContext, RuntimePlugin, RuntimePluginAPI, RuntimePluginExtends, } from '../types/runtime/index.js';
-export type { Collector, ExtendStreamSSRFn, ResolveComponentFn, RuntimeContextProjection, SSRAssetGroup, SSRAssetTransformInfo, SSRHeadData, SSRHeadPart, SSRHtmlFormatting, SSRRenderAsset, SSRRenderInfo, SSRRenderLifecycle, SSRRenderTerminal, SSRRouterData, SSRTemplateChunk, StreamSSRExtender, StreamSSRInfo, StringSSRCollectorsInfo, TransformRuntimeContextFn, } from '../types/runtime/hooks.js';
+export type { Collector, ExtendStreamSSRFn, OnRenderPreparedFn, OnRequestEndFn, ResolveComponentFn, RuntimeContextProjection, SSRAssetGroup, SSRAssetTransformInfo, SSRHeadData, SSRHeadPart, SSRHtmlFormatting, SSRRenderAsset, SSRRenderInfo, SSRRenderLifecycle, SSRRenderTerminal, SSRRequestEndInfo, SSRRequestPreparedInfo, SSRRequestRouterResult, SSRRequestTerminal, SSRRouterData, SSRTemplateChunk, StreamSSRExtender, StreamSSRInfo, StringSSRCollectorsInfo, TransformRuntimeContextFn, } from '../types/runtime/hooks.js';
 export { initPluginAPI } from './api.js';
 export { createRuntimeContext, initRuntimeContext } from './context.js';
 export { initHooks } from './hooks.js';

package/dist/types/server/api.d.ts

@@ -1,4 +1,4 @@
-import { createDebugger } from '@modern-js/utils';
+import { createDebugger } from '@modern-js/utils/cli-common';
 import type { PluginManager } from '../types/plugin.js';
 import type { ServerPluginAPI } from '../types/server/api.js';
 import type { InternalServerContext } from '../types/server/context.js';

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

@@ -1,9 +1,10 @@
+import type { AsyncHook } from '../types/hooks.js';
 import type { ModifyConfigFn, OnPrepareFn, OnResetFn } from '../types/server/hooks.js';
 import type { DeepPartial } from '../types/utils.js';
 export type { ModifyConfigFn, OnPrepareFn, OnResetFn };
-export declare function initHooks<Config>(): {
-    modifyConfig: import("../index.js").AsyncHook<ModifyConfigFn<DeepPartial<Config>>>;
-    onPrepare: import("../index.js").AsyncHook<OnPrepareFn>;
-    onReset: import("../index.js").AsyncHook<OnResetFn>;
+export declare function initHooks<Config>(): Hooks<Config>;
+export type Hooks<Config> = {
+    modifyConfig: AsyncHook<ModifyConfigFn<DeepPartial<Config>>>;
+    onPrepare: AsyncHook<OnPrepareFn>;
+    onReset: AsyncHook<OnResetFn>;
 };
-export type Hooks<Config> = ReturnType<typeof initHooks<Config>>;

package/dist/types/server/run/create.d.ts

@@ -1,7 +1,8 @@
+import type { InternalServerContext } from '../../types/server/context.js';
 import type { ServerPluginExtends } from '../../types/server/plugin.js';
 import type { ServerRunOptions } from './types.js';
 export declare const createServer: <Extends extends ServerPluginExtends>() => {
-    run: (options: ServerRunOptions) => Promise<{
-        serverContext: import("../../index.js").InternalServerContext<Extends>;
+    run(options: ServerRunOptions): Promise<{
+        serverContext: InternalServerContext<Extends>;
     }>;
 };

package/dist/types/server/run/index.d.ts

@@ -1,8 +1,5 @@
+import type { ServerPluginExtends } from '../../types/server/plugin.js';
 import { createServer } from './create.js';
-export declare const server: {
-    run: (options: import("./types.js").ServerRunOptions) => Promise<{
-        serverContext: import("../../index.js").InternalServerContext<import("../../index.js").ServerPluginExtends<{}, {}, {}, {}>>;
-    }>;
-};
+export declare const server: ReturnType<typeof createServer<ServerPluginExtends>>;
 export type { ServerCreateOptions } from './types.js';
 export { createServer };

package/dist/types/server/run/types.d.ts

@@ -1,4 +1,4 @@
-import type { ServerRoute } from '@modern-js/types';
+import type { ServerRoute } from '@modern-js/types/server';
 import type { Plugin } from '../../types/plugin.js';
 /** Registered BFF runtimes. Runtime packages extend this interface. */
 export interface BffRuntimeRegistry {

package/dist/types/types/cli/context.d.ts

@@ -1,5 +1,5 @@
 import type { BuilderInstance } from '@modern-js/builder';
-import type { ServerRoute } from '@modern-js/types';
+import type { ServerRoute } from '@modern-js/types/server';
 import type { Hooks } from '../../cli/hooks.js';
 import type { CLIPluginAPI } from './api.js';
 import type { CLIPlugin, CLIPluginExtends } from './plugin.js';

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

@@ -1,14 +1,13 @@
-import type { ServerPlugin as ServerPluginConfig, ServerRoute } from '@modern-js/types';
+import type { ServerPlugin as ServerPluginConfig } from '@modern-js/types/common';
+import type { ServerRoute } from '@modern-js/types/server';
 import type { Command } from '@modern-js/utils/commander';
 import type { ModifyBundlerChainUtils, ModifyRspackConfigUtils, RsbuildConfig, Rspack, RspackChain } from '@rsbuild/core';
 import type { TransformFunction } from '../plugin.js';
 import type { MaybePromise } from '../utils.js';
 import type { Entrypoint } from './context.js';
-declare module '@modern-js/utils/commander' {
-    interface Command {
-        commandsMap: Map<string, Command>;
-    }
-}
+export type CliProgram = Command & {
+    commandsMap: Map<string, Command>;
+};
 export interface RuntimePluginConfig {
     name: string;
     path: string;
@@ -32,7 +31,7 @@ export type ModifyHtmlPartialsFn = (params: {
     };
 }) => Promise<void> | void;
 export type AddCommandFn = (params: {
-    program: Command;
+    program: CliProgram;
 }) => void;
 export type OnPrepareFn = () => Promise<void> | void;
 type WatchFilesReturnType = Array<string> | {

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

@@ -1,4 +1,4 @@
 export type { CLIPluginAPI } from './api.js';
 export type { AppContext, Entrypoint, InternalContext } from './context.js';
-export type { RuntimePluginConfig, ServerPluginConfig } from './hooks.js';
+export type { CliProgram, RuntimePluginConfig, ServerPluginConfig, } from './hooks.js';
 export type { CLIPlugin, CLIPluginExtends } from './plugin.js';

package/dist/types/types/plugin.d.ts

@@ -37,9 +37,9 @@ export type Plugin<PluginAPI = {}, Context = {}> = {
      */
     required?: string[];
 };
-export type PluginManager = {
-    getPlugins: () => Plugin[];
-    addPlugins: (plugins: Array<Plugin | Falsy>) => void;
+export type PluginManager<PluginAPI = {}, Context = {}> = {
+    getPlugins: () => Plugin<PluginAPI, Context>[];
+    addPlugins: (plugins: Array<Plugin<PluginAPI, Context> | Falsy>) => void;
     clear: () => void;
     isPluginExists: (name: string) => boolean;
 };

package/dist/types/types/runtime/api.d.ts

@@ -1,13 +1,15 @@
 import type { PluginHook, PluginHookTap } from '../hooks.js';
 import type { DeepPartial } from '../utils.js';
 import type { RuntimeContext } from './context.js';
-import type { ConfigFn, ExtendStreamSSRFn, ExtendStringSSRCollectorsFn, Hooks, OnBeforeRenderFn, PickContextFn, ResolveComponentFn, StringSSRCollectorsInfo, TransformRuntimeContextFn, WrapRootFn } from './hooks.js';
+import type { ConfigFn, ExtendStreamSSRFn, ExtendStringSSRCollectorsFn, Hooks, OnBeforeRenderFn, OnRenderPreparedFn, OnRequestEndFn, PickContextFn, ResolveComponentFn, StringSSRCollectorsInfo, TransformRuntimeContextFn, WrapRootFn } from './hooks.js';
 import type { RuntimePluginExtends } from './plugin.js';
 export type RuntimePluginAPI<Extends extends RuntimePluginExtends> = Readonly<{
     updateRuntimeContext: (updateContext: DeepPartial<RuntimeContext>) => void;
     getHooks: () => Readonly<Hooks<Extends['config'], RuntimeContext & Extends['extendContext']> & Extends['extendHooks']>;
     getRuntimeConfig: () => Readonly<Extends['config']>;
     onBeforeRender: PluginHookTap<OnBeforeRenderFn<Extends['extendContext']>>;
+    onRenderPrepared: PluginHookTap<OnRenderPreparedFn<RuntimeContext & Extends['extendContext']>>;
+    onRequestEnd: PluginHookTap<OnRequestEndFn<RuntimeContext & Extends['extendContext']>>;
     wrapRoot: PluginHookTap<WrapRootFn>;
     resolveComponent: PluginHookTap<ResolveComponentFn>;
     pickContext: PluginHookTap<PickContextFn<RuntimeContext>>;

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

@@ -15,6 +15,11 @@ export type SSRRenderInfo<RuntimeContext = object> = {
     /** Original renderer resource and configuration; interpreted by extensions. */
     resource?: object;
     config?: object;
+    /** Request-scoped monitors for diagnostics an extension detects mid-render. */
+    monitors: {
+        error(message: string, ...args: unknown[]): void;
+        warn(message: string, ...args: unknown[]): void;
+    };
 };
 export type SSRHeadPart = {
     toString(): string;
@@ -86,8 +91,34 @@ export type Collector = SSRRenderLifecycle & {
     effect: () => void | Promise<void>;
 };
 import type React from 'react';
-import type { AsyncInterruptHook, CollectSyncHook, SyncHook } from '../hooks.js';
+import type { AsyncHook, AsyncInterruptHook, CollectSyncHook, SyncHook } from '../hooks.js';
 export type OnBeforeRenderFn<RuntimeContext> = (context: RuntimeContext, interrupt: (info: any) => any) => Promise<any> | any;
+export type SSRRequestRouterResult = {
+    statusCode?: number;
+    errors?: Record<string, unknown> | null;
+};
+export type SSRRequestPreparedInfo<RuntimeContext = object> = {
+    runtimeContext: RuntimeContext;
+    /** Native router metadata; extensions may supply another router's result. */
+    routerResult?: SSRRequestRouterResult;
+};
+export type OnRenderPreparedFn<RuntimeContext> = (info: SSRRequestPreparedInfo<RuntimeContext>) => SSRRequestPreparedInfo<RuntimeContext> | void | Promise<SSRRequestPreparedInfo<RuntimeContext> | void>;
+export type SSRRequestTerminal = {
+    status: 'complete';
+} | {
+    status: 'error';
+    error: unknown;
+} | {
+    status: 'cancelled';
+    reason: unknown;
+} | {
+    status: 'discarded';
+};
+export type SSRRequestEndInfo<RuntimeContext = object> = {
+    runtimeContext: RuntimeContext;
+    terminal: SSRRequestTerminal;
+};
+export type OnRequestEndFn<RuntimeContext> = (info: SSRRequestEndInfo<RuntimeContext>) => void | Promise<void>;
 export type ExtendStringSSRCollectorsFn<RuntimeContext> = (context: RuntimeContext) => Collector;
 export type StringSSRCollectorsInfo<RuntimeContext = object> = {
     chunkSet: ChunkSet;
@@ -127,6 +158,10 @@ export type TransformRuntimeContextFn<RuntimeContext> = (projection: RuntimeCont
 export type ConfigFn<RuntimeConfig> = () => RuntimeConfig;
 export type Hooks<RuntimeConfig, RuntimeContext> = {
     onBeforeRender: AsyncInterruptHook<OnBeforeRenderFn<RuntimeContext>>;
+    /** Runs after preparation and before native status/error handling. */
+    onRenderPrepared: AsyncHook<OnRenderPreparedFn<RuntimeContext>>;
+    /** Runs once after response completion, cancellation, discard or failure. */
+    onRequestEnd: AsyncHook<OnRequestEndFn<RuntimeContext>>;
     wrapRoot: SyncHook<WrapRootFn>;
     resolveComponent: SyncHook<ResolveComponentFn>;
     pickContext: SyncHook<PickContextFn<RuntimeContext>>;

package/dist/types/types/server/context.d.ts

@@ -1,4 +1,4 @@
-import type { ServerRoute } from '@modern-js/types';
+import type { ServerRoute } from '@modern-js/types/server';
 import type { BffRuntimeFramework } from '../../server/run/types.js';
 import type { ServerPluginAPI } from './api.js';
 import type { Hooks } from './hooks.js';

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@bleedingdev/modern-js-plugin",
   "description": "A Progressive React Framework for modern web development.",
-  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "homepage": "https://github.com/ultramodernjs/ultramodern.js#readme",
   "bugs": {
-    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+    "url": "https://github.com/ultramodernjs/ultramodern.js/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "url": "git+https://github.com/ultramodernjs/ultramodern.js.git",
     "directory": "packages/toolkit/plugin"
   },
   "license": "MIT",
@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.9.0-ultramodern.9",
+  "version": "3.9.3-ultramodern.10",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "exports": {
@@ -62,7 +62,7 @@
   "typesVersions": {
     "*": {
       ".": [
-        "./dist/index.d.ts"
+        "./dist/types/index.d.ts"
       ],
       "run": [
         "./dist/types/cli/run/index.d.ts"
@@ -79,20 +79,19 @@
     }
   },
   "dependencies": {
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@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",
-    "@rsbuild/core": "2.2.3",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.3-ultramodern.10",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.3-ultramodern.10",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.3-ultramodern.10",
+    "@rsbuild/core": "2.2.13",
     "@swc/helpers": "^0.5.23",
-    "jiti": "^2.7.0"
+    "jiti": "2.7.0"
   },
   "devDependencies": {
-    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.0-ultramodern.9",
-    "@rslib/core": "1.0.0",
-    "@types/node": "^26.4.1",
-    "@types/react": "^19.2.18",
-    "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "typescript": "^7.0.2"
+    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.3-ultramodern.10",
+    "@rslib/core": "1.0.3",
+    "@types/node": "^26.6.5",
+    "@types/react": "^19.3.0",
+    "typescript": "7.0.2"
   },
   "sideEffects": false,
   "publishConfig": {
@@ -102,5 +101,8 @@
     "dev": "rslib build --watch",
     "build": "rslib build",
     "test": "rstest"
+  },
+  "ultramodern": {
+    "sourceName": "@modern-js/plugin"
   }
 }