alemonjs 2.1.81 → 2.1.83

package/lib/app/event-error.d.ts

@@ -0,0 +1,2 @@
+import type { EventErrorContext } from '../types';
+export declare const dispatchEventError: (context: EventErrorContext) => Promise<boolean>;

package/lib/app/event-error.js

@@ -0,0 +1,20 @@
+import { getChildrenApp } from './store.js';
+import { showErrorModule } from '../core/utils.js';
+
+const dispatchEventError = async (context) => {
+    const app = getChildrenApp(context.appName);
+    const onEventError = app?.cycle?.onEventError;
+    if (!onEventError) {
+        return false;
+    }
+    try {
+        const result = await onEventError(context);
+        return result === 'continue';
+    }
+    catch (error) {
+        showErrorModule(error instanceof Error ? error : new Error(typeof error === 'string' ? error : 'onEventError failed'));
+        return false;
+    }
+};
+
+export { dispatchEventError };

package/lib/app/event-processor-callHandler.d.ts

@@ -1 +1,5 @@
-export declare const createCallHandler: (valueEvent: any) => (currents: any, nextEvent: any) => void;
+import type { EventErrorPhase } from '../types';
+export declare const createCallHandler: (valueEvent: any) => (currents: any, nextEvent: any, meta?: {
+    appName?: string;
+    phase?: EventErrorPhase;
+}) => void;

package/lib/app/event-processor-callHandler.js

@@ -3,9 +3,10 @@ import 'path';
 import 'yaml';
 import { showErrorModule } from '../core/utils.js';
 import { withEventContext, finishCurrentTrace } from './hook-event-context.js';
+import { dispatchEventError } from './event-error.js';
 
 const createCallHandler = valueEvent => {
-    const callHandler = (currents, nextEvent) => {
+    const callHandler = (currents, nextEvent, meta) => {
         let index = 0;
         let isClose = false;
         let isNext = false;
@@ -24,7 +25,10 @@ const createCallHandler = valueEvent => {
                     isNext = true;
                     nextEvent(...cns);
                 };
-                const res = await withEventContext(valueEvent, nextFn, () => currents[index](valueEvent, nextFn));
+                const res = await withEventContext(valueEvent, nextFn, () => currents[index](valueEvent, nextFn), {
+                    appName: meta?.appName,
+                    phase: meta?.phase
+                });
                 if (res !== true) {
                     if (!isNext) {
                         finishCurrentTrace('consumed');
@@ -35,7 +39,19 @@ const createCallHandler = valueEvent => {
             }
             catch (err) {
                 finishCurrentTrace('error');
+                const shouldContinue = meta?.appName && meta?.phase
+                    ? await dispatchEventError({
+                        event: valueEvent,
+                        error: err,
+                        appName: meta.appName,
+                        phase: meta.phase
+                    })
+                    : false;
                 showErrorModule(err);
+                if (shouldContinue) {
+                    nextEvent();
+                    return;
+                }
                 return;
             }
             ++index;

package/lib/app/event-processor-cycleFiles.d.ts

@@ -1,4 +1,7 @@
 import { Next, Events, EventKeys, FileTreeNode, StoreResponseItem } from '../types';
 export declare const clearModuleCache: (path?: string) => void;
 export declare const createNextStep: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next, files: StoreResponseItem[], callHandler: (currents: any, nextEvent: any) => void) => Next;
-export declare const createFileTreeStep: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next, root: FileTreeNode, callHandler: (currents: any, nextEvent: any) => void) => Next;
+export declare const createFileTreeStep: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next, root: FileTreeNode, callHandler: (currents: any, nextEvent: any, meta?: {
+    appName?: string;
+    phase?: "middleware" | "response";
+}) => void, phase: "middleware" | "response") => Next;

package/lib/app/event-processor-cycleFiles.js

@@ -1,5 +1,6 @@
 import { getCachedRegExp, showErrorModule } from '../core/utils.js';
 import { EventMessageText } from '../core/variable.js';
+import { dispatchEventError } from './event-error.js';
 
 const moduleCache = new Map();
 const shouldSkipFile = (file, select, valueEvent) => {
@@ -37,7 +38,7 @@ const loadModule = async (filePath) => {
     moduleCache.set(filePath, mod);
     return mod;
 };
-const callHandlerFile = async (valueEvent, select, file, nextStep, callback) => {
+const callHandlerFile = async (valueEvent, select, file, nextStep, callback, phase) => {
     try {
         const app = await loadModule(file.path);
         if (!app?.default?.current || !app?.default?.select) {
@@ -60,8 +61,16 @@ const callHandlerFile = async (valueEvent, select, file, nextStep, callback) =>
         callback(app);
     }
     catch (err) {
+        const shouldContinue = await dispatchEventError({
+            event: valueEvent,
+            error: err,
+            appName: file.appName,
+            phase
+        });
         showErrorModule(err);
-        nextStep();
+        if (shouldContinue) {
+            nextStep();
+        }
     }
 };
 const createNextStep = (valueEvent, select, next, files, callHandler) => {
@@ -94,14 +103,14 @@ const createNextStep = (valueEvent, select, next, files, callHandler) => {
         }, app => {
             const currentsItem = Array.isArray(app.default.current) ? app.default.current : [app.default.current];
             currents.push(...currentsItem);
-        });
+        }, 'response');
         if (currents.length > 0) {
             callHandler(currents, nextStep);
         }
     };
     return nextStep;
 };
-const createFileTreeStep = (valueEvent, select, next, root, callHandler) => {
+const createFileTreeStep = (valueEvent, select, next, root, callHandler, phase) => {
     const processNode = (node, done) => {
         if (node.middleware?.path) {
             void checkMiddleware(node, done);
@@ -123,7 +132,7 @@ const createFileTreeStep = (valueEvent, select, next, root, callHandler) => {
             matched = true;
             const items = Array.isArray(app.default.current) ? app.default.current : [app.default.current];
             mwCurrents.push(...items);
-        });
+        }, 'middleware');
         if (matched) {
             if (mwCurrents.length === 0) {
                 void processContent(node, done);
@@ -141,6 +150,9 @@ const createFileTreeStep = (valueEvent, select, next, root, callHandler) => {
                     return;
                 }
                 void processContent(node, done);
+            }, {
+                appName: node.middleware?.appName,
+                phase
             });
         }
     };
@@ -174,8 +186,11 @@ const createFileTreeStep = (valueEvent, select, next, root, callHandler) => {
                 else {
                     processFiles(node, idx + 1, filesDone, treeDone);
                 }
+            }, {
+                appName: file.appName,
+                phase
             });
-        });
+        }, phase);
     };
     const processChildNodes = (node, done) => {
         const childKeys = Array.from(node.children.keys());

package/lib/app/event-processor-cycleRoute.d.ts

@@ -1,2 +1,5 @@
 import { Next, Events, EventKeys, ResponseRoute } from '../types';
-export declare const createRouteProcessChildren: <T extends EventKeys>(valueEvent: Events[T], select: T, nextCycle: Next, callHandler: (currents: any, nextEvent: any) => void) => (nodes: ResponseRoute[], _pending: any[], next: () => Promise<void> | void) => void;
+export declare const createRouteProcessChildren: <T extends EventKeys>(valueEvent: Events[T], select: T, nextCycle: Next, callHandler: (currents: any, nextEvent: any, meta?: {
+    appName?: string;
+    phase?: "route";
+}) => void, phase: "route") => (nodes: ResponseRoute[], _pending: any[], next: () => Promise<void> | void) => void;

package/lib/app/event-processor-cycleRoute.js

@@ -3,6 +3,7 @@ import 'fs';
 import 'path';
 import 'yaml';
 import { getCachedRegExp, showErrorModule } from '../core/utils.js';
+import { dispatchEventError } from './event-error.js';
 
 const AsyncFunction = (async () => { }).constructor;
 function isAsyncFunction(fn) {
@@ -11,7 +12,7 @@ function isAsyncFunction(fn) {
 function isFunction(value) {
     return isAsyncFunction(value) || typeof value === 'function' || value instanceof Function;
 }
-const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler) => {
+const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler, phase) => {
     const handlerResultCache = new Map();
     const collectHandlers = (tail) => {
         const result = [];
@@ -126,11 +127,24 @@ const createRouteProcessChildren = (valueEvent, select, nextCycle, callHandler)
                         return;
                     }
                     void nextNode();
+                }, {
+                    appName: node.appName,
+                    phase
                 });
             }
             catch (err) {
+                const shouldContinue = typeof node.appName === 'string'
+                    ? await dispatchEventError({
+                        event: valueEvent,
+                        error: err,
+                        appName: node.appName,
+                        phase
+                    })
+                    : false;
                 showErrorModule(err);
-                void nextNode();
+                if (shouldContinue) {
+                    void nextNode();
+                }
             }
         };
         void nextNode();

package/lib/app/event-processor-event.js

@@ -8,10 +8,10 @@ const responseRouterSingleton = new ResponseRouter();
 const expendEvent = (valueEvent, select, next) => {
     const root = responseTreeSingleton.value;
     const callHandler = createCallHandler(valueEvent);
-    const nextEvent = createFileTreeStep(valueEvent, select, next, root, callHandler);
+    const nextEvent = createFileTreeStep(valueEvent, select, next, root, callHandler, 'response');
     const routes = responseRouterSingleton.value;
     const callRouteHandler = createCallHandler(valueEvent);
-    const processChildren = createRouteProcessChildren(valueEvent, select, nextEvent, callRouteHandler);
+    const processChildren = createRouteProcessChildren(valueEvent, select, nextEvent, callRouteHandler, 'route');
     void processChildren(routes, [], nextEvent);
 };
 

package/lib/app/event-processor-middleware.js

@@ -8,10 +8,10 @@ const middlewareRouterSingleton = new MiddlewareRouter();
 const expendMiddleware = (valueEvent, select, next) => {
     const root = middlewareTreeSingleton.value;
     const callHandler = createCallHandler(valueEvent);
-    const nextMiddleware = createFileTreeStep(valueEvent, select, next, root, callHandler);
+    const nextMiddleware = createFileTreeStep(valueEvent, select, next, root, callHandler, 'middleware');
     const routes = middlewareRouterSingleton.value;
     const callRouteHandler = createCallHandler(valueEvent);
-    const processChildren = createRouteProcessChildren(valueEvent, select, nextMiddleware, callRouteHandler);
+    const processChildren = createRouteProcessChildren(valueEvent, select, nextMiddleware, callRouteHandler, 'route');
     void processChildren(routes, [], nextMiddleware);
 };
 

package/lib/app/event-processor-subscribe.js

@@ -5,6 +5,7 @@ import { showErrorModule } from '../core/utils.js';
 import { getSubscribeList } from './store.js';
 import { SubscribeStatus } from './config.js';
 import { withEventContext, finishCurrentTrace } from './hook-event-context.js';
+import { dispatchEventError } from './event-error.js';
 
 const expendSubscribe = (valueEvent, select, next, choose) => {
     const subListValue = getSubscribeList(choose, select);
@@ -64,15 +65,29 @@ const expendSubscribe = (valueEvent, select, next, choose) => {
             }
         };
         try {
-            const result = withEventContext(valueEvent, Continue, () => item.data.current(valueEvent, Continue));
+            const result = withEventContext(valueEvent, Continue, () => item.data.current(valueEvent, Continue), {
+                appName: item.data.appName,
+                phase: 'subscribe'
+            });
             if (result && typeof result.then === 'function') {
                 void result.then(() => {
                     if (!isContinue) {
                         finishCurrentTrace('consumed');
                     }
-                }, error => {
+                }, async (error) => {
                     finishCurrentTrace('error');
+                    const shouldContinue = typeof item.data.appName === 'string'
+                        ? await dispatchEventError({
+                            event: valueEvent,
+                            error,
+                            appName: item.data.appName,
+                            phase: 'subscribe'
+                        })
+                        : false;
                     showErrorModule(error);
+                    if (shouldContinue) {
+                        nextObserver(true);
+                    }
                 });
                 return;
             }
@@ -82,7 +97,20 @@ const expendSubscribe = (valueEvent, select, next, choose) => {
         }
         catch (error) {
             finishCurrentTrace('error');
-            showErrorModule(error);
+            void (async () => {
+                const shouldContinue = typeof item.data.appName === 'string'
+                    ? await dispatchEventError({
+                        event: valueEvent,
+                        error,
+                        appName: item.data.appName,
+                        phase: 'subscribe'
+                    })
+                    : false;
+                showErrorModule(error);
+                if (shouldContinue) {
+                    nextObserver(true);
+                }
+            })();
         }
     };
     nextObserver();

package/lib/app/event-processor.js

@@ -4,6 +4,7 @@ import { expendCycle } from './event-processor-cycle.js';
 import { withProcessorTrace, finishCurrentTrace } from './hook-event-context.js';
 import { ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap } from './store.js';
 import { getCachedRegExp, matchIn, fastHash } from '../core/utils.js';
+import { dispatchEventStart } from './lifecycle-callbacks.js';
 
 const filter = ({ Now, store, INTERVAL }, MessageId) => {
     if (store.has(MessageId)) {
@@ -59,8 +60,12 @@ const callback = () => {
 };
 setTimeout(callback, processorRepeatedClearTimeMin);
 const onProcessor = (name, event, data) => {
-    withProcessorTrace(name, event, () => {
+    void withProcessorTrace(name, event, async () => {
         try {
+            await dispatchEventStart({
+                event,
+                name
+            });
             const value = getConfigValue();
             const disabledTextRegular = value?.disabled_text_regular;
             if (disabledTextRegular && event['MessageText']) {

package/lib/app/hook-event-context.d.ts

@@ -1,10 +1,14 @@
 import { Result } from '../core';
-import { EventKeys, Events } from '../types';
-export type EventTraceReason = 'filtered' | 'completed' | 'consumed' | 'error';
-export declare const withEventContext: <T extends EventKeys, R>(event: Events[T], next: (...args: boolean[]) => void, runner: () => R) => R;
+import { EventErrorPhase, EventKeys, Events, EventTraceReason } from '../types';
+export declare const withEventContext: <T extends EventKeys, R>(event: Events[T], next: (...args: boolean[]) => void, runner: () => R, options?: {
+    appName?: string;
+    phase?: EventErrorPhase;
+}) => R;
 export declare const withProcessorTrace: <T extends EventKeys, R>(select: T, event: Events[T], runner: () => R) => R;
 export declare const getCurrentEvent: <T extends EventKeys>() => Events[T] | undefined;
 export declare const getCurrentNext: () => ((...args: boolean[]) => void) | undefined;
+export declare const getCurrentAppName: () => string | undefined;
+export declare const getCurrentPhase: () => EventErrorPhase | undefined;
 export declare const finishCurrentTrace: (reason: EventTraceReason) => void;
 export declare const markEventSendAttempt: <T extends EventKeys>(event?: Events[T]) => void;
 export declare const markEventSendSuccess: <T extends EventKeys>(event?: Events[T]) => void;

package/lib/app/hook-event-context.js

@@ -2,6 +2,7 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import { performance } from 'node:perf_hooks';
 import { getConfigValue } from '../core/config.js';
 import { ResultCode } from '../core/variable.js';
+import { dispatchEventFinished } from './lifecycle-callbacks.js';
 
 const eventStore = new AsyncLocalStorage();
 const shouldShowLog = (event) => {
@@ -61,19 +62,31 @@ const createEventTrace = (select) => {
                     message: 'event processor finished',
                     data: createLogData(event, trace.select, reason, duration)
                 });
-                return;
             }
-            logger.info(createLogText(event, trace.select, reason, duration));
+            else {
+                logger.info(createLogText(event, trace.select, reason, duration));
+            }
+            void dispatchEventFinished({
+                event,
+                name: trace.select,
+                reason,
+                duration,
+                hasSendAttempted: event._sendAttempted === true || event._has_send_attempt === true,
+                hasSendSucceeded: event._sendSucceeded === true || event._has_send_success === true,
+                lastSendError: event._lastSendError ?? event._last_send_error ?? null
+            });
         }
     };
     return trace;
 };
-const withEventContext = (event, next, runner) => {
+const withEventContext = (event, next, runner, options) => {
     const current = eventStore.getStore();
     return eventStore.run({
         event,
         next,
-        trace: current?.trace
+        trace: current?.trace,
+        appName: options?.appName ?? current?.appName,
+        phase: options?.phase ?? current?.phase
     }, runner);
 };
 const withProcessorTrace = (select, event, runner) => {
@@ -90,6 +103,12 @@ const getCurrentEvent = () => {
 const getCurrentNext = () => {
     return eventStore.getStore()?.next;
 };
+const getCurrentAppName = () => {
+    return eventStore.getStore()?.appName;
+};
+const getCurrentPhase = () => {
+    return eventStore.getStore()?.phase;
+};
 const finishCurrentTrace = (reason) => {
     eventStore.getStore()?.trace?.finish(reason);
 };
@@ -144,4 +163,4 @@ const recordEventSendResults = (results, event) => {
     }
 };
 
-export { finishCurrentTrace, getCurrentEvent, getCurrentNext, markEventSendAttempt, markEventSendFailure, markEventSendSuccess, recordEventSendResults, withEventContext, withProcessorTrace };
+export { finishCurrentTrace, getCurrentAppName, getCurrentEvent, getCurrentNext, getCurrentPhase, markEventSendAttempt, markEventSendFailure, markEventSendSuccess, recordEventSendResults, withEventContext, withProcessorTrace };

package/lib/app/hook-use/subscribe.js

@@ -1,12 +1,13 @@
 import { ResultCode } from '../../core/variable.js';
 import { SubscribeList } from '../store.js';
 import { SubscribeStatus } from '../config.js';
-import { getCurrentEvent } from '../hook-event-context.js';
+import { getCurrentEvent, getCurrentAppName } from '../hook-event-context.js';
 
 function useSubscribe(eventOrSelects, maybeSelects) {
     const selects = (maybeSelects === undefined ? eventOrSelects : maybeSelects);
     const event = (maybeSelects === undefined ? undefined : eventOrSelects);
     const valueEvent = event ?? getCurrentEvent();
+    const appName = getCurrentAppName();
     if (typeof valueEvent !== 'object' || valueEvent === null) {
         logger.error({
             code: ResultCode.FailParams,
@@ -50,6 +51,7 @@ function useSubscribe(eventOrSelects, maybeSelects) {
                 }
             }
             subList.value.append({
+                appName,
                 choose,
                 selects: curSelects,
                 keys: values,

package/lib/app/index.js

@@ -1,4 +1,4 @@
-export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, MiddlewareTree, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, ResponseTree, State, StateSubscribe, SubscribeList, bumpStoreVersion, clearRuntimeAppKoaRouters, core, disposeAllRuntimeApps, disposeRuntimeApp, getRuntimeApp, getRuntimeAppKoaRouters, getSubscribeList, hasRuntimeAppCapability, listRuntimeAppKoaRouters, listRuntimeApps, logger, registerRuntimeApp, setRuntimeAppKoaRouters, toRuntimeAppSnapshot, updateRuntimeAppCapabilities, updateRuntimeAppStatus } from './store.js';
+export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, MiddlewareTree, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, ResponseTree, State, StateSubscribe, SubscribeList, bumpStoreVersion, clearRuntimeAppKoaRouters, core, disposeAllRuntimeApps, disposeRuntimeApp, getChildrenApp, getRuntimeApp, getRuntimeAppKoaRouters, getSubscribeList, hasRuntimeAppCapability, listChildrenApps, listRuntimeAppKoaRouters, listRuntimeApps, logger, registerRuntimeApp, setRuntimeAppKoaRouters, toRuntimeAppSnapshot, updateRuntimeAppCapabilities, updateRuntimeAppStatus } from './store.js';
 export { Expose, clearAllExpose, disposeExpose, registerExpose } from './expose.js';
 export { loadModels, run } from './load_modules/load.js';
 export { loadChildren, loadChildrenFile } from './load_modules/loadChild.js';
@@ -35,7 +35,7 @@ export { useUser } from './hook-use/user.js';
 export { useObserver, useSubscribe } from './hook-use/subscribe.js';
 export { createEvent, useEvent } from './hook-use/event.js';
 export { clearInterval, clearTimeout, listSchedule, pauseSchedule, resumeSchedule, setCron, setInterval, setTimeout } from './api/schedule.js';
-export { finishCurrentTrace, getCurrentEvent, getCurrentNext, markEventSendAttempt, markEventSendFailure, markEventSendSuccess, recordEventSendResults, withEventContext, withProcessorTrace } from './hook-event-context.js';
+export { finishCurrentTrace, getCurrentAppName, getCurrentEvent, getCurrentNext, getCurrentPhase, markEventSendAttempt, markEventSendFailure, markEventSendSuccess, recordEventSendResults, withEventContext, withProcessorTrace } from './hook-event-context.js';
 export { registerAppDir, scheduleCancel, scheduleCancelAll, scheduleCancelByApp, scheduleCron, scheduleInterval, scheduleList, schedulePause, scheduleResume, scheduleTimeout, unregisterAppDir } from './schedule-store.js';
 export { createEventValue, createSelects, onSelects, onState, unChildren, unState, useState } from './event-utils.js';
 export { MessageDirect, createDataFormat, format, getMessageIntent, sendToChannel, sendToUser } from './message-api.js';

package/lib/app/lifecycle-callbacks.d.ts

@@ -0,0 +1,14 @@
+import type { EventFinishedContext, EventStartContext, HttpErrorContext, RuntimeStatusChangeContext } from '../types';
+export declare const dispatchEventStart: (context: EventStartContext) => Promise<void>;
+export declare const dispatchEventFinished: (context: EventFinishedContext) => Promise<void>;
+export declare const dispatchHttpError: (context: HttpErrorContext) => Promise<boolean>;
+export declare const dispatchRuntimeStatusChange: (context: RuntimeStatusChangeContext) => Promise<void>;
+export declare const dispatchAppReady: (appName: string, store: {
+    response: any[];
+    responseMiddleware: {
+        [key: string]: any;
+    };
+    middleware: any[];
+}) => Promise<void>;
+export declare const dispatchAppDispose: (appName: string, error?: unknown) => Promise<void>;
+export declare const dispatchDisposeAllApps: (error?: unknown) => Promise<void>;

package/lib/app/lifecycle-callbacks.js

@@ -0,0 +1,99 @@
+import { showErrorModule } from '../core/utils.js';
+
+const swallowLifecycleError = (error) => {
+    showErrorModule(error instanceof Error ? error : new Error(typeof error === 'string' ? error : 'Unknown lifecycle error'));
+};
+const getChildrenApps = () => {
+    return Object.values(global.alemonjsCore?.storeChildrenApp ?? {});
+};
+const getChildrenApp = (name) => {
+    return global.alemonjsCore?.storeChildrenApp?.[name] ?? null;
+};
+const dispatchEventStart = async (context) => {
+    const apps = getChildrenApps();
+    for (const app of apps) {
+        try {
+            await app.cycle?.onEventStart?.(context);
+        }
+        catch (error) {
+            swallowLifecycleError(error);
+        }
+    }
+};
+const dispatchEventFinished = async (context) => {
+    const apps = getChildrenApps();
+    for (const app of apps) {
+        try {
+            await app.cycle?.onEventFinished?.(context);
+        }
+        catch (error) {
+            swallowLifecycleError(error);
+        }
+    }
+};
+const dispatchHttpError = async (context) => {
+    const app = getChildrenApp(context.appName);
+    const handler = app?.cycle?.onHttpError;
+    if (!handler) {
+        return false;
+    }
+    try {
+        const result = await handler(context);
+        return result === 'handled';
+    }
+    catch (error) {
+        swallowLifecycleError(error);
+        return false;
+    }
+};
+const dispatchRuntimeStatusChange = async (context) => {
+    const app = getChildrenApp(context.appName);
+    const handler = app?.cycle?.onRuntimeStatusChange;
+    if (!handler) {
+        return;
+    }
+    try {
+        await handler(context);
+    }
+    catch (error) {
+        swallowLifecycleError(error);
+    }
+};
+const dispatchAppReady = async (appName, store) => {
+    const app = getChildrenApp(appName);
+    const handler = app?.cycle?.onReady;
+    if (!handler) {
+        return;
+    }
+    try {
+        await handler(store);
+    }
+    catch (error) {
+        throw error;
+    }
+};
+const dispatchAppDispose = async (appName, error) => {
+    const app = getChildrenApp(appName);
+    if (!app?.cycle) {
+        return;
+    }
+    try {
+        if (app.cycle.onDispose) {
+            await app.cycle.onDispose(error);
+        }
+        if (app.cycle.unMounted) {
+            await app.cycle.unMounted(error);
+        }
+    }
+    catch (disposeError) {
+        swallowLifecycleError(disposeError);
+    }
+};
+const dispatchDisposeAllApps = async (error) => {
+    const apps = getChildrenApps();
+    for (const app of apps) {
+        await dispatchAppDispose(app.name, error);
+    }
+};
+
+export { dispatchAppDispose, dispatchAppReady, dispatchDisposeAllApps, dispatchEventFinished, dispatchEventStart, dispatchHttpError, dispatchRuntimeStatusChange };

package/lib/app/load_modules/loadChild.js

@@ -6,6 +6,7 @@ import { registerExpose } from '../expose.js';
 import { ResultCode, fileSuffixMiddleware } from '../../core/variable.js';
 import { registerAppDir, scheduleCancelByApp, unregisterAppDir } from '../schedule-store.js';
 import module$1 from 'module';
+import { dispatchRuntimeStatusChange, dispatchAppDispose, dispatchAppReady } from '../lifecycle-callbacks.js';
 
 const initRequire = () => { };
 initRequire.resolve = () => '';
@@ -89,21 +90,19 @@ const loadChildren = async (mainPath, appName) => {
             app = await moduleApp.default.callback();
         }
         App.pushCycle(app);
+        await dispatchRuntimeStatusChange({
+            appName,
+            previousStatus: 'discovered',
+            status: 'loading'
+        });
         const unMounted = async (e) => {
             showErrorModule(e);
             clearRuntimeAppKoaRouters(appName);
             updateRuntimeAppStatus(appName, 'failed', e);
             scheduleCancelByApp(appName);
             unregisterAppDir(appName);
+            await dispatchAppDispose(appName, e);
             App.un();
-            try {
-                if (app?.unMounted) {
-                    await app.unMounted(e);
-                }
-            }
-            catch (e) {
-                showErrorModule(e);
-            }
         };
         try {
             if (app?.onCreated) {
@@ -133,10 +132,12 @@ const loadChildren = async (mainPath, appName) => {
                 expose: hasExposeCapability
             });
             App.on();
+            const emptyStore = { response: [], responseMiddleware: {}, middleware: [] };
             try {
                 if (app?.onMounted) {
-                    await app.onMounted({ response: [], responseMiddleware: {}, middleware: [] });
+                    await app.onMounted(emptyStore);
                 }
+                await dispatchAppReady(appName, emptyStore);
                 updateRuntimeAppStatus(appName, 'ready');
             }
             catch (e) {
@@ -202,10 +203,12 @@ const loadChildren = async (mainPath, appName) => {
                 event: resData.length > 0 || Object.keys(resAndMwData).length > 0 || mwData.length > 0
             });
             App.on();
+            const mountedStore = { response: resData, responseMiddleware: resAndMwData, middleware: mwData };
             try {
                 if (app?.onMounted) {
-                    await app.onMounted({ response: resData, responseMiddleware: resAndMwData, middleware: mwData });
+                    await app.onMounted(mountedStore);
                 }
+                await dispatchAppReady(appName, mountedStore);
                 updateRuntimeAppStatus(appName, 'ready');
             }
             catch (e) {

package/lib/app/store.d.ts

@@ -187,6 +187,8 @@ export declare class ChildrenApp {
     un(): void;
     get value(): import("../types").StoreChildrenApp;
 }
+export declare const getChildrenApp: (name: string) => import("../types").StoreChildrenApp;
+export declare const listChildrenApps: () => import("../types").StoreChildrenApp[];
 export declare const ProcessorEventAutoClearMap: Map<any, any>;
 export declare const ProcessorEventUserAutoClearMap: Map<any, any>;
 export declare const logger: any;

package/lib/app/store.js

@@ -2,6 +2,7 @@ import { SinglyLinkedList } from './SinglyLinkedList.js';
 import { mkdirSync } from 'node:fs';
 import log4js from 'log4js';
 import { disposeExpose } from './expose.js';
+import { dispatchRuntimeStatusChange } from './lifecycle-callbacks.js';
 
 const createLogger = () => {
     if (process.env.BROWSER_ENV === 'browser') {
@@ -157,11 +158,7 @@ const normalizeRuntimeAppError = (error) => {
     };
 };
 const sameRuntimeAppCapabilities = (left, right) => {
-    return (left.event === right.event &&
-        left.httpApi === right.httpApi &&
-        left.web === right.web &&
-        left.schedule === right.schedule &&
-        left.expose === right.expose);
+    return (left.event === right.event && left.httpApi === right.httpApi && left.web === right.web && left.schedule === right.schedule && left.expose === right.expose);
 };
 const sameRuntimeAppError = (left, right) => {
     if (!left && !right) {
@@ -205,7 +202,7 @@ const registerRuntimeApp = (record) => {
         updatedAt: now
     };
     if (!current || current.status !== record.status) {
-        logRuntimeAppStatus('info', runtimeApps[record.name]);
+        logRuntimeAppStatus(record.status === 'failed' ? 'warn' : 'debug', runtimeApps[record.name]);
     }
     return runtimeApps[record.name];
 };
@@ -216,13 +213,26 @@ const updateRuntimeAppStatus = (name, status, error) => {
         return;
     }
     const normalizedError = normalizeRuntimeAppError(error);
+    const previousStatus = current.status;
     if (current.status === status && sameRuntimeAppError(current.error, normalizedError)) {
         return current;
     }
     current.status = status;
     current.updatedAt = Date.now();
     current.error = normalizedError;
-    logRuntimeAppStatus(status === 'failed' ? 'warn' : 'info', current);
+    const level = status === 'failed' ? 'warn' : status === 'disposed' ? 'info' : 'debug';
+    logRuntimeAppStatus(level, current);
+    void dispatchRuntimeStatusChange({
+        appName: name,
+        previousStatus,
+        status,
+        error: normalizedError
+            ? {
+                message: normalizedError.message,
+                time: normalizedError.time
+            }
+            : undefined
+    });
     return current;
 };
 const updateRuntimeAppCapabilities = (name, capabilities) => {
@@ -411,6 +421,13 @@ function mergeFileTree(target, source) {
         }
     }
 }
+const attachRouteAppName = (appName, routes = []) => {
+    return routes.map(route => ({
+        ...route,
+        appName,
+        children: route.children ? attachRouteAppName(appName, route.children) : route.children
+    }));
+};
 class MiddlewareTree {
     #cache = null;
     #cacheVersion = -1;
@@ -459,10 +476,10 @@ class ResponseRouter {
                 return [];
             }
             if (alemonjsCore.storeChildrenApp[key].register?.responseRouter) {
-                return alemonjsCore.storeChildrenApp[key].register?.responseRouter?.current ?? [];
+                return attachRouteAppName(key, alemonjsCore.storeChildrenApp[key].register?.responseRouter?.current ?? []);
             }
             if (alemonjsCore.storeChildrenApp[key].register?.response) {
-                return alemonjsCore.storeChildrenApp[key].register?.response?.current ?? [];
+                return attachRouteAppName(key, alemonjsCore.storeChildrenApp[key].register?.response?.current ?? []);
             }
             return [];
         });
@@ -483,10 +500,10 @@ class MiddlewareRouter {
                 return [];
             }
             if (alemonjsCore.storeChildrenApp[key].register?.middlewareRouter) {
-                return alemonjsCore.storeChildrenApp[key].register?.middlewareRouter?.current ?? [];
+                return attachRouteAppName(key, alemonjsCore.storeChildrenApp[key].register?.middlewareRouter?.current ?? []);
             }
             if (alemonjsCore.storeChildrenApp[key].register?.middleware) {
-                return alemonjsCore.storeChildrenApp[key].register?.middleware?.current ?? [];
+                return attachRouteAppName(key, alemonjsCore.storeChildrenApp[key].register?.middleware?.current ?? []);
             }
             return [];
         });
@@ -635,6 +652,12 @@ class ChildrenApp {
         return alemonjsCore.storeChildrenApp[this.#name];
     }
 }
+const getChildrenApp = (name) => {
+    return alemonjsCore.storeChildrenApp[name] ?? null;
+};
+const listChildrenApps = () => {
+    return Object.values(alemonjsCore.storeChildrenApp);
+};
 const ProcessorEventAutoClearMap = new Map();
 const ProcessorEventUserAutoClearMap = new Map();
 const logger = new Logger().value;
@@ -648,4 +671,4 @@ process?.on?.('exit', code => {
     logger.info?.(`[alemonjs][exit] 进程退出，code=${code}`);
 });
 
-export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, MiddlewareTree, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, ResponseTree, State, StateSubscribe, SubscribeList, bumpStoreVersion, clearRuntimeAppKoaRouters, core, disposeAllRuntimeApps, disposeRuntimeApp, getRuntimeApp, getRuntimeAppKoaRouters, getSubscribeList, hasRuntimeAppCapability, listRuntimeAppKoaRouters, listRuntimeApps, logger, registerRuntimeApp, setRuntimeAppKoaRouters, toRuntimeAppSnapshot, updateRuntimeAppCapabilities, updateRuntimeAppStatus };
+export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, MiddlewareTree, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, ResponseTree, State, StateSubscribe, SubscribeList, bumpStoreVersion, clearRuntimeAppKoaRouters, core, disposeAllRuntimeApps, disposeRuntimeApp, getChildrenApp, getRuntimeApp, getRuntimeAppKoaRouters, getSubscribeList, hasRuntimeAppCapability, listChildrenApps, listRuntimeAppKoaRouters, listRuntimeApps, logger, registerRuntimeApp, setRuntimeAppKoaRouters, toRuntimeAppSnapshot, updateRuntimeAppCapabilities, updateRuntimeAppStatus };

package/lib/client.js

@@ -34,20 +34,27 @@ import './app/message-api.js';
 import './process/platform.js';
 import './process/module.js';
 import { createServer } from './server/main.js';
+import { dispatchDisposeAllApps } from './app/lifecycle-callbacks.js';
 
 global.__client_loaded = true;
 let runtimeDisposed = false;
-const disposeRuntime = () => {
+const disposeRuntime = async () => {
     if (runtimeDisposed) {
         return;
     }
     runtimeDisposed = true;
+    await dispatchDisposeAllApps();
     const apps = disposeAllRuntimeApps();
     apps.forEach(app => {
         scheduleCancelByApp(app.name);
         unregisterAppDir(app.name);
     });
 };
+const shutdown = async (reason) => {
+    logger.info?.(`[alemonjs][${reason}] 收到信号，正在关闭...`);
+    await disposeRuntime();
+    process.exit(0);
+};
 const mainServer = () => {
     const port = process.env.serverPort;
     if (!port) {
@@ -83,13 +90,11 @@ const mainProcess = () => {
     });
     ['SIGINT', 'SIGTERM', 'SIGQUIT', 'disconnect'].forEach(sig => {
         process?.on?.(sig, () => {
-            logger.info?.(`[alemonjs][${sig}] 收到信号，正在关闭...`);
-            disposeRuntime();
-            setImmediate(() => process.exit(0));
+            void shutdown(sig);
         });
     });
     process?.on?.('exit', code => {
-        disposeRuntime();
+        void disposeRuntime();
         logger.info?.(`[alemonjs][exit] 进程退出，code=${code}`);
     });
     process.on('message', msg => {
@@ -100,8 +105,7 @@ const mainProcess = () => {
                 mainServer();
             }
             else if (data?.type === 'stop') {
-                disposeRuntime();
-                process.exit(0);
+                void shutdown('stop');
             }
         }
         catch { }

package/lib/core/config.d.ts

@@ -1,6 +1,9 @@
 import type { Package } from '../types';
 type ConfigValue = {
     [key: string]: any;
+    apps?: string[] | {
+        [key: string]: boolean;
+    };
     master_key?: {
         [key: string]: boolean;
     } | string[];
@@ -35,9 +38,6 @@ type ConfigValue = {
         repeated_event_time?: number;
         repeated_user_time?: number;
     };
-    apps?: string[] | {
-        [key: string]: boolean;
-    };
 };
 type ConfigListener<T extends ConfigValue = ConfigValue> = (value: T) => void;
 declare class ConfigCore<T extends ConfigValue = ConfigValue> {

package/lib/index.js

@@ -5,7 +5,7 @@ export { createEventName, createHash, createResult, createUserHashKey, fastHash,
 export { cbpClient } from './cbp/connects/client.js';
 export { cbpPlatform } from './cbp/connects/platform.js';
 export { cbpServer } from './cbp/server/main.js';
-export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, MiddlewareTree, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, ResponseTree, State, StateSubscribe, SubscribeList, bumpStoreVersion, clearRuntimeAppKoaRouters, core, disposeAllRuntimeApps, disposeRuntimeApp, getRuntimeApp, getRuntimeAppKoaRouters, getSubscribeList, hasRuntimeAppCapability, listRuntimeAppKoaRouters, listRuntimeApps, logger, registerRuntimeApp, setRuntimeAppKoaRouters, toRuntimeAppSnapshot, updateRuntimeAppCapabilities, updateRuntimeAppStatus } from './app/store.js';
+export { ChildrenApp, Core, Logger, Middleware, MiddlewareRouter, MiddlewareTree, ProcessorEventAutoClearMap, ProcessorEventUserAutoClearMap, Response, ResponseMiddleware, ResponseRouter, ResponseTree, State, StateSubscribe, SubscribeList, bumpStoreVersion, clearRuntimeAppKoaRouters, core, disposeAllRuntimeApps, disposeRuntimeApp, getChildrenApp, getRuntimeApp, getRuntimeAppKoaRouters, getSubscribeList, hasRuntimeAppCapability, listChildrenApps, listRuntimeAppKoaRouters, listRuntimeApps, logger, registerRuntimeApp, setRuntimeAppKoaRouters, toRuntimeAppSnapshot, updateRuntimeAppCapabilities, updateRuntimeAppStatus } from './app/store.js';
 export { Expose, clearAllExpose, disposeExpose, registerExpose } from './app/expose.js';
 export { loadModels, run } from './app/load_modules/load.js';
 export { loadChildren, loadChildrenFile } from './app/load_modules/loadChild.js';
@@ -42,7 +42,7 @@ export { useUser } from './app/hook-use/user.js';
 export { useObserver, useSubscribe } from './app/hook-use/subscribe.js';
 export { createEvent, useEvent } from './app/hook-use/event.js';
 export { clearInterval, clearTimeout, listSchedule, pauseSchedule, resumeSchedule, setCron, setInterval, setTimeout } from './app/api/schedule.js';
-export { finishCurrentTrace, getCurrentEvent, getCurrentNext, markEventSendAttempt, markEventSendFailure, markEventSendSuccess, recordEventSendResults, withEventContext, withProcessorTrace } from './app/hook-event-context.js';
+export { finishCurrentTrace, getCurrentAppName, getCurrentEvent, getCurrentNext, getCurrentPhase, markEventSendAttempt, markEventSendFailure, markEventSendSuccess, recordEventSendResults, withEventContext, withProcessorTrace } from './app/hook-event-context.js';
 export { registerAppDir, scheduleCancel, scheduleCancelAll, scheduleCancelByApp, scheduleCron, scheduleInterval, scheduleList, schedulePause, scheduleResume, scheduleTimeout, unregisterAppDir } from './app/schedule-store.js';
 export { createEventValue, createSelects, onSelects, onState, unChildren, unState, useState } from './app/event-utils.js';
 export { MessageDirect, createDataFormat, format, getMessageIntent, sendToChannel, sendToUser } from './app/message-api.js';

package/lib/server/routers/router.js

@@ -10,6 +10,7 @@ import { ResultCode } from '../../core/variable.js';
 import 'yaml';
 import '../../core/utils.js';
 import { listRuntimeApps, getRuntimeApp, toRuntimeAppSnapshot, listRuntimeAppKoaRouters, hasRuntimeAppCapability, getRuntimeAppKoaRouters } from '../../app/store.js';
+import { dispatchHttpError } from '../../app/lifecycle-callbacks.js';
 
 const initRequire = () => { };
 initRequire.resolve = () => '';
@@ -104,14 +105,41 @@ const dispatchRegisteredKoaRouters = async (ctx) => {
         }
         const routers = getRuntimeAppKoaRouters(item.name);
         for (const koaRouter of routers) {
-            const beforeMatched = Array.isArray(ctx.matched) ? ctx.matched.length : 0;
-            await koaRouter.routes()(ctx, async () => { });
-            const afterMatched = Array.isArray(ctx.matched) ? ctx.matched.length : 0;
-            if (afterMatched <= beforeMatched) {
-                continue;
+            try {
+                const beforeMatched = Array.isArray(ctx.matched) ? ctx.matched.length : 0;
+                await koaRouter.routes()(ctx, async () => { });
+                const afterMatched = Array.isArray(ctx.matched) ? ctx.matched.length : 0;
+                if (afterMatched <= beforeMatched) {
+                    continue;
+                }
+                await koaRouter.allowedMethods()(ctx, async () => { });
+                return true;
+            }
+            catch (error) {
+                const handled = await dispatchHttpError({
+                    ctx,
+                    error,
+                    appName: item.name,
+                    path: ctx.path,
+                    method: ctx.method,
+                    kind: 'koa-router'
+                });
+                if (handled) {
+                    return true;
+                }
+                logger.warn({
+                    code: ResultCode.Fail,
+                    message: `Error request ${ctx.path}:`,
+                    data: error instanceof Error ? error.message : String(error)
+                });
+                ctx.status = 500;
+                ctx.body = {
+                    code: 500,
+                    message: '处理 Koa Router 请求时发生错误。',
+                    error: error instanceof Error ? error.message : String(error)
+                };
+                return true;
             }
-            await koaRouter.allowedMethods()(ctx, async () => { });
-            return true;
         }
     }
     return false;
@@ -239,12 +267,22 @@ router.all('app/{*path}', async (ctx) => {
             await runMiddlewares(middlewares, ctx, handler);
         }
         catch (err) {
-            console.error(`Error handling API request ${ctx.path}`);
+            const handled = await dispatchHttpError({
+                ctx,
+                error: err,
+                appName: 'main',
+                path: ctx.path,
+                method: ctx.method,
+                kind: 'api'
+            });
+            if (handled) {
+                return;
+            }
             ctx.status = 500;
             ctx.body = {
                 code: 500,
                 message: '处理 API 请求时发生错误。',
-                error: err.message
+                error: err instanceof Error ? err.message : String(err)
             };
         }
         return;
@@ -264,11 +302,22 @@ router.all('app/{*path}', async (ctx) => {
         root = readWebRootConfig(packageRoot);
     }
     catch (err) {
+        const handled = await dispatchHttpError({
+            ctx,
+            error: err,
+            appName: 'main',
+            path: ctx.path,
+            method: ctx.method,
+            kind: 'web'
+        });
+        if (handled) {
+            return;
+        }
         ctx.status = 500;
         ctx.body = {
             code: 500,
             message: '加载 package.json 时发生错误。',
-            error: err.message
+            error: err instanceof Error ? err.message : String(err)
         };
         return;
     }
@@ -291,6 +340,17 @@ router.all('app/{*path}', async (ctx) => {
         ctx.status = 200;
     }
     catch (err) {
+        const handled = await dispatchHttpError({
+            ctx,
+            error: err,
+            appName: 'main',
+            path: ctx.path,
+            method: ctx.method,
+            kind: 'web'
+        });
+        if (handled) {
+            return;
+        }
         if (err?.status === 404) {
             ctx.status = 404;
             ctx.body = {
@@ -304,7 +364,7 @@ router.all('app/{*path}', async (ctx) => {
             ctx.body = {
                 code: 500,
                 message: '加载资源时发生服务器错误。',
-                error: err.message
+                error: err instanceof Error ? err.message : String(err)
             };
         }
     }
@@ -370,16 +430,27 @@ router.all('apps/:app/{*path}', async (ctx) => {
             await runMiddlewares(middlewares, ctx, handler);
         }
         catch (err) {
+            const handled = await dispatchHttpError({
+                ctx,
+                error: err,
+                appName,
+                path: ctx.path,
+                method: ctx.method,
+                kind: 'api'
+            });
+            if (handled) {
+                return;
+            }
             logger.warn({
                 code: ResultCode.Fail,
                 message: `Error request ${ctx.path}:`,
-                data: err?.message ?? ''
+                data: err instanceof Error ? err.message : String(err)
             });
             ctx.status = 500;
             ctx.body = {
                 code: 500,
                 message: '处理 API 请求时发生错误。',
-                error: err.message
+                error: err instanceof Error ? err.message : String(err)
             };
         }
         return;
@@ -399,11 +470,22 @@ router.all('apps/:app/{*path}', async (ctx) => {
         root = readWebRootConfig(packageRoot);
     }
     catch (err) {
+        const handled = await dispatchHttpError({
+            ctx,
+            error: err,
+            appName,
+            path: ctx.path,
+            method: ctx.method,
+            kind: 'web'
+        });
+        if (handled) {
+            return;
+        }
         ctx.status = 500;
         ctx.body = {
             code: 500,
             message: '加载 package.json 时发生错误。',
-            error: err.message
+            error: err instanceof Error ? err.message : String(err)
         };
         return;
     }
@@ -426,6 +508,17 @@ router.all('apps/:app/{*path}', async (ctx) => {
         ctx.status = 200;
     }
     catch (err) {
+        const handled = await dispatchHttpError({
+            ctx,
+            error: err,
+            appName,
+            path: ctx.path,
+            method: ctx.method,
+            kind: 'web'
+        });
+        if (handled) {
+            return;
+        }
         if (err?.status === 404) {
             ctx.status = 404;
             ctx.body = {
@@ -438,13 +531,13 @@ router.all('apps/:app/{*path}', async (ctx) => {
             logger.warn({
                 code: ResultCode.Fail,
                 message: `Error request ${ctx.path}:`,
-                data: err?.message ?? ''
+                data: err instanceof Error ? err.message : String(err)
             });
             ctx.status = 500;
             ctx.body = {
                 code: 500,
                 message: `加载子应用 '${appName}' 资源时发生服务器错误。`,
-                error: err.message
+                error: err instanceof Error ? err.message : String(err)
             };
         }
     }

package/lib/types/cycle/index.d.ts

@@ -1,4 +1,7 @@
 import { StoreMiddlewareItem, StoreResponseItem } from '../store/res';
+import { Events } from '../event';
+import { EventKeys } from '../event/map';
+import type KoaRouter from 'koa-router';
 type StroreParam = {
     response: StoreResponseItem[];
     responseMiddleware: {
@@ -6,10 +9,57 @@ type StroreParam = {
     };
     middleware: StoreMiddlewareItem[];
 };
+export type EventErrorPhase = 'middleware' | 'response' | 'subscribe' | 'route';
+export type EventTraceReason = 'filtered' | 'completed' | 'consumed' | 'error';
+export type RuntimeLifecycleStatus = 'discovered' | 'loading' | 'ready' | 'failed' | 'disposed';
+export type EventStartContext<T extends EventKeys = EventKeys> = {
+    event: Events[T];
+    name: T;
+};
+export type EventFinishedContext<T extends EventKeys = EventKeys> = {
+    event: Events[T];
+    name: T;
+    reason: EventTraceReason;
+    duration: number;
+    hasSendAttempted: boolean;
+    hasSendSucceeded: boolean;
+    lastSendError: string | null;
+};
+export type EventErrorContext<T extends EventKeys = EventKeys> = {
+    event: Events[T];
+    error: unknown;
+    appName: string;
+    phase: EventErrorPhase;
+};
+export type HttpErrorKind = 'api' | 'web' | 'koa-router';
+export type HttpErrorContext = {
+    ctx: KoaRouter.RouterContext;
+    error: unknown;
+    appName: string;
+    path: string;
+    method: string;
+    kind: HttpErrorKind;
+};
+export type RuntimeStatusChangeContext = {
+    appName: string;
+    previousStatus?: RuntimeLifecycleStatus;
+    status: RuntimeLifecycleStatus;
+    error?: {
+        message: string;
+        time: number;
+    };
+};
 export type ChildrenCycle = {
     onCreated?: () => void | Promise<void>;
     onMounted?: (store: StroreParam) => void | Promise<void>;
+    onReady?: (store: StroreParam) => void | Promise<void>;
+    onEventStart?: <T extends EventKeys>(context: EventStartContext<T>) => void | Promise<void>;
+    onEventError?: <T extends EventKeys>(context: EventErrorContext<T>) => void | 'continue' | Promise<void | 'continue'>;
+    onEventFinished?: <T extends EventKeys>(context: EventFinishedContext<T>) => void | Promise<void>;
+    onHttpError?: (context: HttpErrorContext) => void | 'handled' | Promise<void | 'handled'>;
+    onRuntimeStatusChange?: (context: RuntimeStatusChangeContext) => void | Promise<void>;
     unMounted?: (error: any) => void | Promise<void>;
+    onDispose?: (error?: unknown) => void | Promise<void>;
 };
 export type Next = (...cns: boolean[]) => void;
 export type EventCycleEnum = 'create' | 'mount' | 'unmount';

package/lib/types/event/index.d.ts

@@ -35,6 +35,7 @@ export type OnDataFormatFunc = (...data: DataEnums[]) => DataEnums[];
 export type OnGroupItem<C = any, T extends EventKeys = EventKeys> = OnResponseValue<C, T> | OnMiddlewareValue<C, T>;
 export type OnGroupFunc = <C, T extends EventKeys, TFirst extends OnGroupItem<C, T>>(...calls: [TFirst, ...Array<TFirst>]) => TFirst;
 export type ResponseRoute = {
+    appName?: string;
     platform?: string | string[];
     regular?: RegExp;
     prefix?: string;

package/lib/types/subscribe/index.d.ts

@@ -2,6 +2,7 @@ import { SinglyLinkedList } from '../../app/SinglyLinkedList';
 import { EventCycleEnum } from '../cycle';
 import { EventKeys } from '../event/map';
 export type SubscribeValue = {
+    appName?: string;
     choose: EventCycleEnum;
     selects: EventKeys[];
     keys: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.81",
+  "version": "2.1.83",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",