alemonjs 2.1.83 → 2.1.84

package/lib/{cbp → application/runtime/cbp}/connects/client.js

@@ -1,70 +1,74 @@
 import * as flattedJSON from 'flatted';
-import '../../app/store.js';
+import { onProcessor } from '../../event-processor.js';
 import 'fs';
 import 'path';
 import 'yaml';
-import { ResultCode } from '../../core/variable.js';
-import '../../app/load_modules/loadChild.js';
-import '../../app/define-children.js';
-import '../../app/define-response.js';
-import '../../app/define-middleware.js';
-import '../../app/event-group.js';
-import '../../app/event-middleware.js';
-import { onProcessor } from '../../app/event-processor.js';
-import '../../app/event-response.js';
-import { createResult } from '../../core/utils.js';
-import '../../app/hook-event-context.js';
-import { apiResolves, apiTimeouts, actionResolves, actionTimeouts, FULL_RECEIVE_HEADER } from '../processor/config.js';
+import '../../../../common/logger.js';
+import { ResultCode } from '../../../../common/variable.js';
+import { createResult } from '../../../../common/result.js';
+import '../../../../common/utils.js';
+import { createDirectServer } from '../../../../common/direct-channel.js';
+import { FULL_RECEIVE_HEADER } from '../../../../common/cbp/constants.js';
+import '../../../../common/cbp/runtime.js';
+import { createWSConnector } from '../../../../common/cbp/ws-connector.js';
+import { normalizeInboundMessage } from '../../../../common/cbp/normalize.js';
+import { apiRequestResolves, apiRequestTimeouts, actionRequestResolves, actionRequestTimeouts } from '../processor/request-registry.js';
 import { setDirectSend } from '../processor/transport.js';
-import '../../app/message-format-old.js';
-import 'cron';
-import '../../app/event-utils.js';
-import '../../app/message-api.js';
-import { createWSConnector } from './base.js';
-import { createDirectServer } from '../../process/direct-channel.js';
 
-const handleParsedMessage = (parsedMessage) => {
-    if (parsedMessage?.apiId) {
-        const resolve = apiResolves.get(parsedMessage.apiId);
+const handleInboundMessage = (message) => {
+    const normalized = normalizeInboundMessage(message);
+    if (!normalized) {
+        return;
+    }
+    if (normalized.kind === 'api.res') {
+        const resolve = apiRequestResolves.get(normalized.replyTo);
         if (resolve) {
-            apiResolves.delete(parsedMessage.apiId);
-            const timeout = apiTimeouts.get(parsedMessage.apiId);
+            apiRequestResolves.delete(normalized.replyTo);
+            const timeout = apiRequestTimeouts.get(normalized.replyTo);
             if (timeout) {
-                apiTimeouts.delete(parsedMessage.apiId);
+                apiRequestTimeouts.delete(normalized.replyTo);
                 clearTimeout(timeout);
             }
-            if (Array.isArray(parsedMessage.payload)) {
-                resolve(parsedMessage.payload);
+            if (Array.isArray(normalized.results)) {
+                resolve(normalized.results);
             }
             else {
                 resolve([createResult(ResultCode.Fail, '接口处理错误', null)]);
             }
         }
     }
-    else if (parsedMessage?.actionId) {
-        const resolve = actionResolves.get(parsedMessage.actionId);
+    else if (normalized.kind === 'action.res') {
+        const resolve = actionRequestResolves.get(normalized.replyTo);
         if (resolve) {
-            actionResolves.delete(parsedMessage.actionId);
-            const timeout = actionTimeouts.get(parsedMessage.actionId);
+            actionRequestResolves.delete(normalized.replyTo);
+            const timeout = actionRequestTimeouts.get(normalized.replyTo);
             if (timeout) {
-                actionTimeouts.delete(parsedMessage.actionId);
+                actionRequestTimeouts.delete(normalized.replyTo);
                 clearTimeout(timeout);
             }
-            if (Array.isArray(parsedMessage.payload)) {
-                resolve(parsedMessage.payload);
+            if (Array.isArray(normalized.results)) {
+                resolve(normalized.results);
             }
             else {
                 resolve([createResult(ResultCode.Fail, '消费处理错误', null)]);
             }
         }
     }
-    else if (parsedMessage.name) {
-        onProcessor(parsedMessage.name, parsedMessage, parsedMessage.value);
+    else if (normalized.kind === 'event') {
+        onProcessor(normalized.eventName, normalized.event, normalized.raw);
+    }
+    else if (normalized.kind === 'control' && normalized.op === 'sync') {
+        const env = normalized.payload?.env;
+        if (env && typeof env === 'object') {
+            for (const key in env) {
+                process.env[key] = String(env[key]);
+            }
+        }
     }
 };
 const cbpClientDirect = (sockPath, open) => {
     createDirectServer(sockPath, (data) => {
-        handleParsedMessage(data);
+        handleInboundMessage(data);
     })
         .then(channel => {
         setDirectSend(channel.send);
@@ -89,7 +93,7 @@ const cbpClientIPC = (open) => {
         try {
             const msg = typeof message === 'string' ? JSON.parse(message) : message;
             if (msg?.type === 'ipc:data') {
-                handleParsedMessage(msg.data);
+                handleInboundMessage(msg.data);
             }
         }
         catch (error) {
@@ -128,18 +132,7 @@ const cbpClient = (url, options = {}) => {
         onMessage: (messageStr) => {
             try {
                 const parsedMessage = flattedJSON.parse(messageStr);
-                if (parsedMessage?.activeId) {
-                    if (parsedMessage.active === 'sync') {
-                        const configs = parsedMessage.payload;
-                        const env = configs.env || {};
-                        for (const key in env) {
-                            process.env[key] = env[key];
-                        }
-                    }
-                }
-                else {
-                    handleParsedMessage(parsedMessage);
-                }
+                handleInboundMessage(parsedMessage);
             }
             catch (error) {
                 logger.error({

package/lib/application/runtime/cbp/index.d.ts

@@ -0,0 +1,3 @@
+export { cbpClient } from './connects/client.js';
+export { sendAction } from './processor/actions.js';
+export { sendAPI } from './processor/api.js';

package/lib/application/runtime/cbp/index.js

@@ -0,0 +1,3 @@
+export { cbpClient } from './connects/client.js';
+export { sendAction } from './processor/actions.js';
+export { sendAPI } from './processor/api.js';

package/lib/application/runtime/cbp/processor/actions.d.ts

@@ -0,0 +1,3 @@
+import { Result } from '../../../../common/index.js';
+import type { Actions } from '../../../../types/index.js';
+export declare const sendAction: (data: Actions) => Promise<Result[]>;

package/lib/application/runtime/cbp/processor/actions.js

@@ -0,0 +1,58 @@
+import * as flattedJSON from 'flatted';
+import 'fs';
+import 'path';
+import 'yaml';
+import '../../../../common/logger.js';
+import { ResultCode } from '../../../../common/variable.js';
+import { createResult } from '../../../../common/result.js';
+import { sanitizeForSerialization } from '../../../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import { timeoutTime } from '../../../../common/cbp/constants.js';
+import { generateUniqueId, deviceId } from '../../../../common/cbp/runtime.js';
+import 'ws';
+import { createActionRequestEnvelope } from '../../../../common/cbp/normalize.js';
+import { actionRequestResolves, actionRequestTimeouts } from './request-registry.js';
+import { getDirectSend } from './transport.js';
+
+const setupActionResolve = (requestId, resolve) => {
+    actionRequestResolves.set(requestId, resolve);
+    const timeout = setTimeout(() => {
+        if (!actionRequestResolves.has(requestId) || !actionRequestTimeouts.has(requestId)) {
+            return;
+        }
+        actionRequestResolves.delete(requestId);
+        actionRequestTimeouts.delete(requestId);
+        resolve([createResult(ResultCode.Fail, '行为超时', null)]);
+    }, timeoutTime);
+    actionRequestTimeouts.set(requestId, timeout);
+};
+const sendAction = (data) => {
+    const requestId = generateUniqueId();
+    return new Promise(resolve => {
+        data.actionId = requestId;
+        data.DeviceId = deviceId;
+        const envelope = createActionRequestEnvelope(data);
+        const safeData = sanitizeForSerialization(envelope);
+        const directSend = getDirectSend();
+        if (directSend) {
+            directSend(safeData);
+            setupActionResolve(requestId, resolve);
+            return;
+        }
+        if (process.env.__ALEMON_IPC === '1' && typeof process.send === 'function') {
+            process.send({ type: 'ipc:data', data: safeData });
+            setupActionResolve(requestId, resolve);
+            return;
+        }
+        if (!global.chatbotClient?.send) {
+            resolve([createResult(ResultCode.Fail, 'Chatbot client is not available', null)]);
+            return;
+        }
+        global.chatbotClient?.send(flattedJSON.stringify(safeData));
+        setupActionResolve(requestId, resolve);
+    });
+};
+
+export { sendAction };

package/lib/application/runtime/cbp/processor/api.d.ts

@@ -0,0 +1,3 @@
+import { Result } from '../../../../common/index.js';
+import type { Apis } from '../../../../types/index.js';
+export declare const sendAPI: (data: Apis) => Promise<Result[]>;

package/lib/application/runtime/cbp/processor/api.js

@@ -0,0 +1,58 @@
+import 'fs';
+import 'path';
+import 'yaml';
+import '../../../../common/logger.js';
+import { ResultCode } from '../../../../common/variable.js';
+import { createResult } from '../../../../common/result.js';
+import { sanitizeForSerialization } from '../../../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import * as flattedJSON from 'flatted';
+import { timeoutTime } from '../../../../common/cbp/constants.js';
+import { generateUniqueId, deviceId } from '../../../../common/cbp/runtime.js';
+import 'ws';
+import { createApiRequestEnvelope } from '../../../../common/cbp/normalize.js';
+import { apiRequestResolves, apiRequestTimeouts } from './request-registry.js';
+import { getDirectSend } from './transport.js';
+
+const setupApiResolve = (requestId, resolve) => {
+    apiRequestResolves.set(requestId, resolve);
+    const timeout = setTimeout(() => {
+        if (!apiRequestResolves.has(requestId) || !apiRequestTimeouts.has(requestId)) {
+            return;
+        }
+        apiRequestResolves.delete(requestId);
+        apiRequestTimeouts.delete(requestId);
+        resolve([createResult(ResultCode.Fail, '接口超时', null)]);
+    }, timeoutTime);
+    apiRequestTimeouts.set(requestId, timeout);
+};
+const sendAPI = (data) => {
+    const requestId = generateUniqueId();
+    return new Promise(resolve => {
+        data.apiId = requestId;
+        data.DeviceId = deviceId;
+        const envelope = createApiRequestEnvelope(data);
+        const safeData = sanitizeForSerialization(envelope);
+        const directSend = getDirectSend();
+        if (directSend) {
+            directSend(safeData);
+            setupApiResolve(requestId, resolve);
+            return;
+        }
+        if (process.env.__ALEMON_IPC === '1' && typeof process.send === 'function') {
+            process.send({ type: 'ipc:data', data: safeData });
+            setupApiResolve(requestId, resolve);
+            return;
+        }
+        if (!global.chatbotClient?.send) {
+            resolve([createResult(ResultCode.Fail, 'Chatbot client is not available', null)]);
+            return;
+        }
+        global.chatbotClient?.send(flattedJSON.stringify(safeData));
+        setupApiResolve(requestId, resolve);
+    });
+};
+
+export { sendAPI };

package/lib/application/runtime/cbp/processor/request-registry.d.ts

@@ -0,0 +1,8 @@
+import type { Result } from '../../../../common/index.js';
+type RequestReplyValue = Result[] | PromiseLike<Result[]>;
+type RequestReplyResolve = (value: RequestReplyValue) => void;
+export declare const actionRequestResolves: Map<string, RequestReplyResolve>;
+export declare const apiRequestResolves: Map<string, RequestReplyResolve>;
+export declare const actionRequestTimeouts: Map<string, NodeJS.Timeout>;
+export declare const apiRequestTimeouts: Map<string, NodeJS.Timeout>;
+export {};

package/lib/application/runtime/cbp/processor/request-registry.js

@@ -0,0 +1,6 @@
+const actionRequestResolves = new Map();
+const apiRequestResolves = new Map();
+const actionRequestTimeouts = new Map();
+const apiRequestTimeouts = new Map();
+
+export { actionRequestResolves, actionRequestTimeouts, apiRequestResolves, apiRequestTimeouts };

package/lib/application/runtime/client-runtime.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/application/runtime/client-runtime.js

@@ -0,0 +1,95 @@
+import { cbpClient } from './cbp/connects/client.js';
+import 'flatted';
+import 'fs';
+import 'path';
+import 'yaml';
+import '../../common/logger.js';
+import { defaultPort } from '../../common/variable.js';
+import '../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import '../../common/cbp/runtime.js';
+import 'ws';
+import { loadModels } from './load-modules/load.js';
+import { createServer } from './http-server.js';
+import { disposeAllRuntimeApps } from './store.js';
+import { scheduleCancelByApp, unregisterAppDir } from './schedule-store.js';
+import { dispatchDisposeAllApps } from './lifecycle-callbacks.js';
+
+global.__client_loaded = true;
+let runtimeDisposed = false;
+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) {
+        return;
+    }
+    createServer(port, () => {
+        const httpURL = `http://127.0.0.1:${port}`;
+        logger.info(`应用服务器: ${httpURL}`);
+    });
+};
+const main = () => {
+    const login = process.env.login ?? '';
+    const platform = process.env.platform ?? '';
+    const url = process.env.url ?? '';
+    const port = process.env.port ?? defaultPort;
+    const isFullReceive = process.env.is_full_receive === 'true' || process.env.is_full_receive === '1';
+    if (!login && !platform && url) {
+        logger.info(`[Connecting to CBP server at ${url}]`);
+        cbpClient(url);
+    }
+    else {
+        cbpClient(`http://127.0.0.1:${port}`, { isFullReceive });
+    }
+    loadModels();
+};
+const mainProcess = () => {
+    process.on('unhandledRejection', (reason) => {
+        logger.error('[alemonjs][unhandledRejection] 未捕获的 Promise 拒绝:', reason);
+    });
+    process.on('uncaughtException', (error) => {
+        logger.error('[alemonjs][uncaughtException] 未捕获的异常:', error);
+    });
+    ['SIGINT', 'SIGTERM', 'SIGQUIT', 'disconnect'].forEach(sig => {
+        process?.on?.(sig, () => void shutdown(sig));
+    });
+    process?.on?.('exit', code => {
+        void disposeRuntime();
+        logger.info?.(`[alemonjs][exit] 进程退出，code=${code}`);
+    });
+    process.on('message', msg => {
+        try {
+            const data = typeof msg === 'string' ? JSON.parse(msg) : msg;
+            if (data?.type === 'start') {
+                main();
+                mainServer();
+            }
+            else if (data?.type === 'stop') {
+                void shutdown('stop');
+            }
+        }
+        catch { }
+    });
+    if (process.send) {
+        process.send({ type: 'ready' });
+    }
+};
+mainProcess();

package/lib/{app → application/runtime}/event-error.d.ts

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

package/lib/{app → application/runtime}/event-error.js

@@ -1,5 +1,5 @@
 import { getChildrenApp } from './store.js';
-import { showErrorModule } from '../core/utils.js';
+import { showErrorModule } from '../../common/utils.js';
 
 const dispatchEventError = async (context) => {
     const app = getChildrenApp(context.appName);

package/lib/{app → application/runtime}/event-group.d.ts

@@ -1,3 +1,3 @@
-import { OnGroupFunc } from '../types';
+import { OnGroupFunc } from '../../types/index.js';
 declare const onGroup: OnGroupFunc;
 export { onGroup };

package/lib/{app → application/runtime}/event-middleware.d.ts

@@ -1,3 +1,3 @@
-import { OnMiddlewareReversalFunc, OnMiddlewareReversalFuncBack } from '../types';
+import { OnMiddlewareReversalFunc, OnMiddlewareReversalFuncBack } from '../../types/index.js';
 export declare const onMiddleware: OnMiddlewareReversalFunc;
 export declare const OnMiddleware: OnMiddlewareReversalFuncBack;

package/lib/{app → application/runtime}/event-middleware.js

@@ -1,4 +1,4 @@
-import { ResultCode } from '../core/variable.js';
+import { ResultCode } from '../../common/variable.js';
 
 const onMiddleware = (select, callback) => {
     if (typeof callback !== 'function') {

package/lib/{app → application/runtime}/event-processor-callHandler.d.ts

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

package/lib/{app → application/runtime}/event-processor-callHandler.js

@@ -1,7 +1,14 @@
 import 'fs';
 import 'path';
 import 'yaml';
-import { showErrorModule } from '../core/utils.js';
+import '../../common/logger.js';
+import { showErrorModule } from '../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import 'flatted';
+import '../../common/cbp/runtime.js';
+import 'ws';
 import { withEventContext, finishCurrentTrace } from './hook-event-context.js';
 import { dispatchEventError } from './event-error.js';
 

package/lib/{app → application/runtime}/event-processor-cycle.d.ts

@@ -1,2 +1,2 @@
-import { Events, EventKeys } from '../types';
+import { Events, EventKeys } from '../../types/index.js';
 export declare const expendCycle: <T extends EventKeys>(valueEvent: Events[T], select: T, _config?: any) => void;

package/lib/{app → application/runtime}/event-processor-cycleFiles.d.ts

@@ -1,4 +1,4 @@
-import { Next, Events, EventKeys, FileTreeNode, StoreResponseItem } from '../types';
+import { Next, Events, EventKeys, FileTreeNode, StoreResponseItem } from '../../types/index.js';
 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, meta?: {

package/lib/{app → application/runtime}/event-processor-cycleFiles.js

@@ -1,5 +1,5 @@
-import { getCachedRegExp, showErrorModule } from '../core/utils.js';
-import { EventMessageText } from '../core/variable.js';
+import { getCachedRegExp, showErrorModule } from '../../common/utils.js';
+import { EventMessageText } from '../../common/variable.js';
 import { dispatchEventError } from './event-error.js';
 
 const moduleCache = new Map();

package/lib/{app → application/runtime}/event-processor-cycleRoute.d.ts

@@ -1,4 +1,4 @@
-import { Next, Events, EventKeys, ResponseRoute } from '../types';
+import { Next, Events, EventKeys, ResponseRoute } from '../../types/index.js';
 export declare const createRouteProcessChildren: <T extends EventKeys>(valueEvent: Events[T], select: T, nextCycle: Next, callHandler: (currents: any, nextEvent: any, meta?: {
     appName?: string;
     phase?: "route";

package/lib/{app → application/runtime}/event-processor-cycleRoute.js

@@ -1,8 +1,15 @@
-import { EventMessageText } from '../core/variable.js';
+import { EventMessageText } from '../../common/variable.js';
 import 'fs';
 import 'path';
 import 'yaml';
-import { getCachedRegExp, showErrorModule } from '../core/utils.js';
+import '../../common/logger.js';
+import { getCachedRegExp, showErrorModule } from '../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import 'flatted';
+import '../../common/cbp/runtime.js';
+import 'ws';
 import { dispatchEventError } from './event-error.js';
 
 const AsyncFunction = (async () => { }).constructor;

package/lib/{app → application/runtime}/event-processor-event.d.ts

@@ -1,2 +1,2 @@
-import { Next, Events, EventKeys } from '../types';
+import { Next, Events, EventKeys } from '../../types/index.js';
 export declare const expendEvent: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next) => void;

package/lib/{app → application/runtime}/event-processor-middleware.d.ts

@@ -1,2 +1,2 @@
-import { Next, Events, EventKeys } from '../types';
+import { Next, Events, EventKeys } from '../../types/index.js';
 export declare const expendMiddleware: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next) => void;

package/lib/{app → application/runtime}/event-processor-subscribe.d.ts

@@ -1,4 +1,4 @@
-import { Next, Events, EventCycleEnum, EventKeys } from '../types';
+import { Next, Events, EventCycleEnum, EventKeys } from '../../types/index.js';
 export declare const expendSubscribe: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next, choose: EventCycleEnum) => void;
 export declare const expendSubscribeCreate: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next) => void;
 export declare const expendSubscribeMount: <T extends EventKeys>(valueEvent: Events[T], select: T, next: Next) => void;

package/lib/{app → application/runtime}/event-processor-subscribe.js

@@ -1,9 +1,16 @@
 import 'fs';
 import 'path';
 import 'yaml';
-import { showErrorModule } from '../core/utils.js';
+import '../../common/logger.js';
+import { showErrorModule } from '../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import 'flatted';
+import '../../common/cbp/runtime.js';
+import 'ws';
 import { getSubscribeList } from './store.js';
-import { SubscribeStatus } from './config.js';
+import { SubscribeStatus } from './subscribe-status.js';
 import { withEventContext, finishCurrentTrace } from './hook-event-context.js';
 import { dispatchEventError } from './event-error.js';
 

package/lib/{app → application/runtime}/event-processor.d.ts

@@ -1,3 +1,3 @@
-import { EventKeys, Events } from '../types';
+import { EventKeys, Events } from '../../types/index.js';
 export declare const onProcessor: <T extends EventKeys>(name: T, event: Events[T], data?: any) => void;
 export declare const OnProcessor: <T extends EventKeys>(event: Events[T], name: T) => void;

package/lib/{app → application/runtime}/event-processor.js

@@ -1,10 +1,11 @@
-import { getConfigValue } from '../core/config.js';
-import { processorRepeatedClearTimeMin, processorRepeatedClearTimeMax, processorRepeatedEventTime, processorRepeatedUserTime, processorRepeatedClearSize, processorMaxMapSize } from '../core/variable.js';
+import { getConfigValue } from '../../common/config.js';
+import { processorRepeatedClearTimeMin, processorRepeatedClearTimeMax, processorRepeatedEventTime, processorRepeatedUserTime, processorRepeatedClearSize, processorMaxMapSize } from '../../common/variable.js';
 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 { getCachedRegExp } from '../../common/utils.js';
 import { dispatchEventStart } from './lifecycle-callbacks.js';
+import { matchIn, fastHash } from '../../common/identity.js';
 
 const filter = ({ Now, store, INTERVAL }, MessageId) => {
     if (store.has(MessageId)) {

package/lib/{app → application/runtime}/event-response.d.ts

@@ -1,3 +1,3 @@
-import { OnResponseReversalFunc, OnResponseReversalFuncBack } from '../types';
+import { OnResponseReversalFunc, OnResponseReversalFuncBack } from '../../types/index.js';
 export declare const onResponse: OnResponseReversalFunc;
 export declare const OnResponse: OnResponseReversalFuncBack;

package/lib/{app → application/runtime}/event-utils.d.ts

@@ -1,4 +1,4 @@
-import { EventKeys } from '../types';
+import { EventKeys } from '../../types/index.js';
 type BaseMap = {
     [key: string]: unknown;
 };

package/lib/{app → application/runtime}/event-utils.js

@@ -1,6 +1,6 @@
-import { getConfig } from '../core/config.js';
+import { getConfig } from '../../common/config.js';
 import { StateSubscribe, ChildrenApp, State } from './store.js';
-import { ResultCode } from '../core/variable.js';
+import { ResultCode } from '../../common/variable.js';
 
 const unChildren = (name = 'main') => {
     if (!name || typeof name !== 'string') {

package/lib/{app → application/runtime}/hook-event-context.d.ts

@@ -1,5 +1,5 @@
-import { Result } from '../core';
-import { EventErrorPhase, EventKeys, Events, EventTraceReason } from '../types';
+import { Result } from '../../common/index.js';
+import { EventErrorPhase, EventKeys, Events, EventTraceReason } from '../../types/index.js';
 export declare const withEventContext: <T extends EventKeys, R>(event: Events[T], next: (...args: boolean[]) => void, runner: () => R, options?: {
     appName?: string;
     phase?: EventErrorPhase;

package/lib/{app → application/runtime}/hook-event-context.js

@@ -1,7 +1,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 { getConfigValue } from '../../common/config.js';
+import { ResultCode } from '../../common/variable.js';
 import { dispatchEventFinished } from './lifecycle-callbacks.js';
 
 const eventStore = new AsyncLocalStorage();

package/lib/application/runtime/http/index.d.ts

@@ -0,0 +1,4 @@
+export { createServer } from '../http-server.js';
+export { default as MessageRouter } from './routers/router.js';
+export * from './routers/middleware.js';
+export * from './routers/utils.js';

package/lib/application/runtime/http/index.js

@@ -0,0 +1,4 @@
+export { createServer } from '../http-server.js';
+export { default as MessageRouter } from './routers/router.js';
+export { collectMiddlewares, runMiddlewares } from './routers/middleware.js';
+export { formatPath, getModuelFile, isValidPackageName, safePath } from './routers/utils.js';

package/lib/application/runtime/http/routers/hello.html.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeAppRecord } from '../../store.js';
+export declare const renderHelloHtml: (apps: RuntimeAppRecord[]) => string;
+declare const _default: string;
+export default _default;