alemonjs 2.1.82 → 2.1.83-alpha.2

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/application/runtime/event-error.d.ts

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

package/lib/application/runtime/event-error.js

@@ -0,0 +1,20 @@
+import { getChildrenApp } from './store.js';
+import { showErrorModule } from '../../common/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 → 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/application/runtime/event-processor-callHandler.d.ts

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

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

@@ -1,11 +1,19 @@
 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';
 
 const createCallHandler = valueEvent => {
-    const callHandler = (currents, nextEvent) => {
+    const callHandler = (currents, nextEvent, meta) => {
         let index = 0;
         let isClose = false;
         let isNext = false;
@@ -24,7 +32,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 +46,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 → 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,7 @@
-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) => 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 → application/runtime}/event-processor-cycleFiles.js

@@ -1,5 +1,6 @@
-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();
 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/application/runtime/event-processor-cycleRoute.d.ts

@@ -0,0 +1,5 @@
+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";
+}) => void, phase: "route") => (nodes: ResponseRoute[], _pending: any[], next: () => Promise<void> | void) => void;