alemonjs 2.1.83 → 2.1.85

package/lib/common/logger.js

@@ -0,0 +1,99 @@
+import { mkdirSync } from 'node:fs';
+import log4js from 'log4js';
+
+const createLogger = () => {
+    if (process.env.BROWSER_ENV === 'browser') {
+        return {
+            trace: console.trace.bind(console),
+            debug: console.debug.bind(console),
+            info: console.info.bind(console),
+            mark: console.info.bind(console),
+            warn: console.warn.bind(console),
+            error: console.error.bind(console),
+            fatal: console.error.bind(console)
+        };
+    }
+    const logDir = process.env?.LOG_PATH ?? `./logs/${process.env.LOG_NAME ?? ''}`;
+    mkdirSync(logDir, { recursive: true });
+    const level = process.env.NODE_ENV === 'development' ? 'trace' : 'info';
+    const hideTime = process.env.LOGGER_TIME === 'false';
+    const hideLevel = process.env.LOGGER_LEVEL === 'false';
+    let pattern = '';
+    if (hideTime && hideLevel) {
+        pattern = '%m';
+    }
+    else if (hideTime && !hideLevel) {
+        pattern = '[%p] %m';
+    }
+    else if (!hideTime && hideLevel) {
+        pattern = '[%d{yyyy-MM-dd hh:mm:ss}] %m';
+    }
+    else {
+        pattern = '[%d{yyyy-MM-dd hh:mm:ss}][%p] %m';
+    }
+    log4js.configure({
+        appenders: {
+            console: {
+                type: 'console',
+                layout: {
+                    type: 'pattern',
+                    pattern
+                }
+            },
+            command: {
+                type: 'dateFile',
+                filename: `${logDir}/command`,
+                pattern: 'yyyy-MM-dd.log',
+                numBackups: 15,
+                alwaysIncludePattern: true,
+                layout: {
+                    type: 'pattern',
+                    pattern
+                }
+            },
+            error: {
+                type: 'dateFile',
+                filename: `${logDir}/error`,
+                pattern: 'yyyy-MM-dd.log',
+                numBackups: 15,
+                alwaysIncludePattern: true,
+                layout: {
+                    type: 'pattern',
+                    pattern
+                }
+            }
+        },
+        categories: {
+            default: { appenders: ['console'], level },
+            command: { appenders: ['console', 'command'], level: 'info' },
+            error: { appenders: ['console', 'command', 'error'], level: 'warn' }
+        }
+    });
+    const defaultLogger = log4js.getLogger('default');
+    const commandLogger = log4js.getLogger('command');
+    const errorLogger = log4js.getLogger('error');
+    return {
+        trace: defaultLogger.trace.bind(defaultLogger),
+        debug: defaultLogger.debug.bind(defaultLogger),
+        info: commandLogger.info.bind(commandLogger),
+        mark: commandLogger.mark.bind(commandLogger),
+        warn: errorLogger.warn.bind(errorLogger),
+        error: errorLogger.error.bind(errorLogger),
+        fatal: errorLogger.fatal.bind(errorLogger)
+    };
+};
+class Logger {
+    #logger = null;
+    constructor() {
+        this.#logger = createLogger();
+        if (!global.logger) {
+            global.logger = this.#logger;
+        }
+    }
+    get value() {
+        return this.#logger;
+    }
+}
+const logger = new Logger().value;
+
+export { Logger, logger };

package/lib/{core → common}/react.js

@@ -32,7 +32,7 @@ class Component {
 function attrsToString(props = {}) {
     const parts = [];
     for (const key of Object.keys(props)) {
-        if (key === 'children') {
+        if (key === 'children' || key === 'dangerouslySetInnerHTML') {
             continue;
         }
         const val = props[key];
@@ -59,6 +59,16 @@ function attrsToString(props = {}) {
     return parts.length ? ' ' + parts.join(' ') : '';
 }
 const voidTags = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+const rawTextTags = new Set(['script', 'style']);
+function renderRawText(vnode) {
+    if (vnode === null || vnode === undefined || vnode === false) {
+        return '';
+    }
+    if (typeof vnode === 'string' || typeof vnode === 'number') {
+        return String(vnode);
+    }
+    return renderToString(vnode);
+}
 function renderToString(vnode) {
     if (vnode === null || vnode === undefined || vnode === false) {
         return '';
@@ -92,12 +102,21 @@ function renderToString(vnode) {
     if (voidTags.has(tag.toLowerCase())) {
         return `<${tag}${attrs} />`;
     }
-    const children = (vnode.children ?? []).map(renderToString).join('');
+    const children = rawTextTags.has(tag.toLowerCase()) ? (vnode.children ?? []).map(renderRawText).join('') : (vnode.children ?? []).map(renderToString).join('');
     return `<${tag}${attrs}>${children}</${tag}>`;
 }
 function makeTag(tag) {
     return function tagFactory(first, ...restChildren) {
-        const looksLikeProps = first !== null && typeof first === 'object' && !Array.isArray(first) && Object.prototype.toString.call(first) === '[object Object]';
+        const looksLikeVNode = first !== null &&
+            typeof first === 'object' &&
+            !Array.isArray(first) &&
+            Object.prototype.toString.call(first) === '[object Object]' &&
+            ('type' in first || 'children' in first);
+        const looksLikeProps = first !== null &&
+            typeof first === 'object' &&
+            !Array.isArray(first) &&
+            Object.prototype.toString.call(first) === '[object Object]' &&
+            !looksLikeVNode;
         if (looksLikeProps) {
             return createElement(tag, first, ...restChildren);
         }

package/lib/common/result.d.ts

@@ -0,0 +1,7 @@
+import { ResultCode } from './variable.js';
+export type Result<T = any> = {
+    code: ResultCode;
+    message: string | object;
+    data: T;
+};
+export declare const createResult: <T>(code: ResultCode, message: string | object, data?: T) => Result<T>;

package/lib/common/result.js

@@ -0,0 +1,19 @@
+import { logger } from './logger.js';
+import { ResultCode } from './variable.js';
+
+const createResult = (code, message, data) => {
+    if (code !== ResultCode.Ok) {
+        logger.error({
+            code,
+            message,
+            data
+        });
+    }
+    return {
+        code,
+        message,
+        data
+    };
+};
+
+export { createResult };

package/lib/{core → common}/utils.d.ts

@@ -1,21 +1,12 @@
 import { Dirent } from 'fs';
-import { ResultCode } from './variable';
+export { createUserHashKey, fastHash, isMaster, matchIn, useUserHashKey } from './identity.js';
+export type { Result } from './result.js';
+export { createResult } from './result.js';
 export declare const createHash: (str: string, options?: {
     length?: number;
     algorithm?: string;
 }) => string;
-export declare const fastHash: (str: string) => string;
 export declare const getCachedRegExp: (pattern: string | RegExp) => RegExp;
-export declare const createUserHashKey: (event: {
-    UserId: string;
-    Platform: string;
-}) => string;
-export declare const useUserHashKey: (event: {
-    UserId: string;
-    Platform: string;
-}) => string;
-export declare const matchIn: (source: any, key: string) => boolean;
-export declare const isMaster: (UserId: string, platform: string) => boolean;
 export declare const createEventName: (url: string, appKey: string) => string;
 export declare const stringToNumber: (str: string, size?: number) => number;
 export declare const getRecursiveDirFiles: (dir: string, condition?: (func: Dirent) => boolean) => {
@@ -25,9 +16,3 @@ export declare const getRecursiveDirFiles: (dir: string, condition?: (func: Dire
 export declare const showErrorModule: (e: Error) => void;
 export declare const sanitizeForSerialization: (data: any) => any;
 export declare const getInputExportPath: (input?: string) => any;
-export type Result<T = any> = {
-    code: ResultCode;
-    message: string | object;
-    data: T;
-};
-export declare const createResult: <T>(code: ResultCode, message: string | object, data?: T) => Result<T>;

package/lib/{core → common}/utils.js

@@ -1,9 +1,11 @@
 import { createHash as createHash$1 } from 'node:crypto';
 import fs__default, { existsSync, readdirSync } from 'fs';
 import path__default, { join } from 'path';
-import { ResultCode, fileSuffixResponse } from './variable.js';
 import module$1 from 'module';
-import { getConfigValue } from './config.js';
+import { ResultCode, fileSuffixResponse } from './variable.js';
+import { logger } from './logger.js';
+export { createUserHashKey, fastHash, isMaster, matchIn, useUserHashKey } from './identity.js';
+export { createResult } from './result.js';
 
 const initRequire = () => { };
 initRequire.resolve = () => '';
@@ -13,14 +15,6 @@ const createHash = (str, options = {}) => {
     const hash = createHash$1(algorithm).update(str).digest('hex');
     return hash.slice(0, length);
 };
-const fastHash = (str) => {
-    let hash = 0x811c9dc5;
-    for (let i = 0; i < str.length; i++) {
-        hash ^= str.charCodeAt(i);
-        hash = Math.imul(hash, 0x01000193);
-    }
-    return (hash >>> 0).toString(36);
-};
 const _regexpCache = new Map();
 const getCachedRegExp = (pattern) => {
     if (pattern instanceof RegExp) {
@@ -33,28 +27,6 @@ const getCachedRegExp = (pattern) => {
     }
     return cached;
 };
-const createUserHashKey = (event) => {
-    return fastHash(`${event.Platform}:${event.UserId}`);
-};
-const useUserHashKey = createUserHashKey;
-const matchIn = (source, key) => {
-    if (Array.isArray(source)) {
-        return source.includes(key);
-    }
-    if (source && typeof source === 'object') {
-        return Object.prototype.hasOwnProperty.call(source, key) && !!source[key];
-    }
-    return false;
-};
-const isMaster = (UserId, platform) => {
-    const values = getConfigValue() || {};
-    const value = values[platform] && typeof values[platform] === 'object' ? values[platform] : {};
-    const UserKey = createUserHashKey({
-        Platform: platform,
-        UserId: UserId
-    });
-    return matchIn(values.master_key, UserKey) || matchIn(values.master_id, UserId) || matchIn(value.master_key, UserKey) || matchIn(value.master_id, UserId);
-};
 const createEventName = (url, appKey) => {
     let uri = url;
     if (process.platform === 'win32') {
@@ -62,8 +34,7 @@ const createEventName = (url, appKey) => {
     }
     const names = uri.split('/').filter(item => item !== '');
     names.pop();
-    const name = `${appKey}:${names.join(':')}`;
-    return name;
+    return `${appKey}:${names.join(':')}`;
 };
 const stringToNumber = (str, size = 33) => {
     let hash = 5381;
@@ -140,19 +111,5 @@ const getInputExportPath = (input) => {
         }
     }
 };
-const createResult = (code, message, data) => {
-    if (code !== ResultCode.Ok) {
-        logger.error({
-            code,
-            message,
-            data: data
-        });
-    }
-    return {
-        code,
-        message,
-        data: data
-    };
-};
 
-export { createEventName, createHash, createResult, createUserHashKey, fastHash, getCachedRegExp, getInputExportPath, getRecursiveDirFiles, isMaster, matchIn, sanitizeForSerialization, showErrorModule, stringToNumber, useUserHashKey };
+export { createEventName, createHash, getCachedRegExp, getInputExportPath, getRecursiveDirFiles, sanitizeForSerialization, showErrorModule, stringToNumber };

package/lib/{core → common}/variable.js

@@ -61,7 +61,7 @@ class Result {
             this.#data[this.#currentIndex] = {
                 code: ResultCode.Ok,
                 message: '',
-                data: data
+                data
             };
         }
         this.#data[this.#currentIndex].data = data;

package/lib/core/cbp/index.d.ts

@@ -0,0 +1 @@
+export { cbpServer } from './server/main.js';

package/lib/core/cbp/index.js

@@ -0,0 +1 @@
+export { cbpServer } from './server/main.js';

package/lib/core/cbp/processor/config.d.ts

@@ -0,0 +1,8 @@
+import { WebSocket } from 'ws';
+export declare const childrenClient: Map<string, WebSocket>;
+export declare const platformClient: Map<string, WebSocket>;
+export declare const fullClient: Map<string, WebSocket>;
+export declare const childrenBind: Map<string, string>;
+export declare const clientBindCount: Map<string, number>;
+export declare const bindChannelToClient: (channelId: string, clientId: string) => void;
+export declare const unbindClient: (clientId: string) => void;

package/lib/core/cbp/processor/config.js

@@ -0,0 +1,29 @@
+const childrenClient = new Map();
+const platformClient = new Map();
+const fullClient = new Map();
+const childrenBind = new Map();
+const clientBindCount = new Map();
+const bindChannelToClient = (channelId, clientId) => {
+    const oldClientId = childrenBind.get(channelId);
+    if (oldClientId && oldClientId !== clientId) {
+        const oldCount = clientBindCount.get(oldClientId) ?? 0;
+        if (oldCount > 1) {
+            clientBindCount.set(oldClientId, oldCount - 1);
+        }
+        else {
+            clientBindCount.delete(oldClientId);
+        }
+    }
+    childrenBind.set(channelId, clientId);
+    clientBindCount.set(clientId, (clientBindCount.get(clientId) ?? 0) + 1);
+};
+const unbindClient = (clientId) => {
+    for (const [channelId, boundClientId] of childrenBind.entries()) {
+        if (boundClientId === clientId) {
+            childrenBind.delete(channelId);
+        }
+    }
+    clientBindCount.delete(clientId);
+};
+
+export { bindChannelToClient, childrenBind, childrenClient, clientBindCount, fullClient, platformClient, unbindClient };

package/lib/{cbp → core/cbp}/routers/hello.html.js

@@ -1,4 +1,4 @@
-import { Component, Head, Title, Style, Body, H1, P, A, Div, Html } from '../../core/react.js';
+import { Component, Head, Title, Style, Body, H1, P, A, Div, Html } from '../../../common/react.js';
 
 class App extends Component {
     render() {

package/lib/{cbp → core/cbp}/server/main.js

@@ -3,15 +3,59 @@ import { WebSocketServer, WebSocket } from 'ws';
 import * as flattedJSON from 'flatted';
 import koaCors from '@koa/cors';
 import router from '../routers/router.js';
-import { ResultCode } from '../../core/variable.js';
 import 'fs';
 import 'path';
 import 'yaml';
-import '../../core/utils.js';
-import { USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, platformClient, childrenClient, fullClient, childrenBind, clientBindCount, unbindClient, bindChannelToClient } from '../processor/config.js';
+import '../../../common/logger.js';
+import { ResultCode } from '../../../common/variable.js';
+import '../../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import { USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, DEVICE_ID_HEADER, FULL_RECEIVE_HEADER } from '../../../common/cbp/constants.js';
+import '../../../common/cbp/runtime.js';
+import { normalizeInboundMessage, getNormalizedDeviceId, getNormalizedEventRouteId, isNormalizedActionRequest, toLegacyActionData, isNormalizedApiRequest, toLegacyApiData } from '../../../common/cbp/normalize.js';
+import { platformClient, childrenClient, fullClient, childrenBind, clientBindCount, unbindClient, bindChannelToClient } from '../processor/config.js';
 import { createTestOneController } from './testone.js';
 import { getClientChild } from '../../process/ipc-bridge.js';
 
+const stringifyForSocket = (payload) => {
+    return flattedJSON.stringify(payload);
+};
+const normalizeTestOneOutboundMessage = (message) => {
+    try {
+        const inbound = flattedJSON.parse(String(message));
+        const normalized = normalizeInboundMessage(inbound);
+        if (isNormalizedActionRequest(normalized)) {
+            return stringifyForSocket(toLegacyActionData(normalized));
+        }
+        if (isNormalizedApiRequest(normalized)) {
+            return stringifyForSocket(toLegacyApiData(normalized));
+        }
+    }
+    catch {
+    }
+    return message.toString();
+};
+const routeNormalizedMessage = (message, input) => {
+    const normalized = normalizeInboundMessage(input);
+    if (!normalized) {
+        return { normalized: null, handled: false };
+    }
+    if (normalized.kind === 'api.res' || normalized.kind === 'action.res') {
+        const resolvedDeviceId = getNormalizedDeviceId(normalized);
+        if (resolvedDeviceId) {
+            routeMessageToDevice(resolvedDeviceId, message);
+        }
+        return { normalized, handled: true };
+    }
+    if (normalized.kind === 'event') {
+        const routeId = getNormalizedEventRouteId(normalized);
+        handleEvent(message, routeId || '');
+        return { normalized, handled: true };
+    }
+    return { normalized, handled: false };
+};
 const routeMessageToDevice = (DeviceId, message) => {
     if (childrenClient.has(DeviceId)) {
         const clientWs = childrenClient.get(DeviceId);
@@ -130,7 +174,7 @@ const setChildrenClient = (originId, ws) => {
     ws.on('message', (message) => {
         if (global.__sandbox) {
             if (global.testoneClient?.readyState === WebSocket.OPEN) {
-                global.testoneClient.send(message.toString());
+                global.testoneClient.send(normalizeTestOneOutboundMessage(message.toString()));
             }
             return;
         }
@@ -167,7 +211,7 @@ const setFullClient = (originId, ws) => {
     ws.on('message', (message) => {
         if (global.__sandbox) {
             if (global.testoneClient?.readyState === WebSocket.OPEN) {
-                global.testoneClient.send(message.toString());
+                global.testoneClient.send(normalizeTestOneOutboundMessage(message.toString()));
             }
             return;
         }
@@ -204,24 +248,13 @@ const setPlatformClient = (originId, ws) => {
     platformClient.set(originId, ws);
     ws.on('message', (message) => {
         try {
-            const parsedMessage = flattedJSON.parse(message.toString());
+            const inbound = flattedJSON.parse(message.toString());
+            routeNormalizedMessage(message.toString(), inbound);
             logger.debug({
                 code: ResultCode.Ok,
                 message: '服务端接收到消息',
-                data: parsedMessage
+                data: inbound
             });
-            if (parsedMessage.apiId) {
-                const DeviceId = parsedMessage.DeviceId;
-                routeMessageToDevice(DeviceId, message);
-            }
-            else if (parsedMessage?.actionId) {
-                const DeviceId = parsedMessage.DeviceId;
-                routeMessageToDevice(DeviceId, message);
-            }
-            else if (parsedMessage?.name) {
-                const ID = parsedMessage.ChannelId || parsedMessage.GuildId || parsedMessage.DeviceId;
-                handleEvent(message, ID);
-            }
         }
         catch (error) {
             logger.error({
@@ -255,26 +288,15 @@ const setTestOnePlatformClient = (ws) => {
     const controller = createTestOneController(ws);
     ws.on('message', (message) => {
         try {
-            const parsedMessage = flattedJSON.parse(message.toString());
+            const inbound = flattedJSON.parse(message.toString());
+            const { handled } = routeNormalizedMessage(message.toString(), inbound);
             logger.debug({
                 code: ResultCode.Ok,
                 message: '测试端接收到消息',
-                data: parsedMessage
+                data: inbound
             });
-            if (parsedMessage.apiId) {
-                const DeviceId = parsedMessage.DeviceId;
-                routeMessageToDevice(DeviceId, message);
-            }
-            else if (parsedMessage?.actionId) {
-                const DeviceId = parsedMessage.DeviceId;
-                routeMessageToDevice(DeviceId, message);
-            }
-            else if (parsedMessage?.name) {
-                const ID = parsedMessage.ChannelId || parsedMessage.GuildId || parsedMessage.DeviceId;
-                handleEvent(message, ID);
-            }
-            else {
-                controller.onMessage(parsedMessage);
+            if (!handled) {
+                controller.onMessage(inbound);
             }
         }
         catch (error) {

package/lib/{cbp → core/cbp}/server/testone.d.ts

@@ -1,6 +1,6 @@
 import { IncomingMessage } from 'http';
 import { WebSocket } from 'ws';
-import type { ParsedMessage } from '../typings';
+import type { ParsedMessage } from '../../../common/cbp/typings.js';
 export declare const createTestOneController: (ws: WebSocket, _request: IncomingMessage) => {
     onMessage: (parsedMessage: ParsedMessage) => void;
     close: () => void;

package/lib/{cbp → core/cbp}/server/testone.js

@@ -3,9 +3,15 @@ import { join, dirname } from 'path';
 import { existsSync, mkdirSync, watch, readFileSync, writeFile } from 'fs';
 import _ from 'lodash';
 import { readFile } from 'fs/promises';
-import { ResultCode } from '../../core/variable.js';
 import 'yaml';
-import '../../core/utils.js';
+import '../../../common/logger.js';
+import { ResultCode } from '../../../common/variable.js';
+import '../../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import '../../../common/cbp/runtime.js';
+import 'ws';
 
 const createTestOneController = (ws, _request) => {
     const testonePath = join(process.cwd(), 'testone');

package/lib/core/index.d.ts

@@ -1,3 +1 @@
-export { ResultCode } from './variable.js';
-export * from './config.js';
-export * from './utils.js';
+export { start } from './start.js';

package/lib/core/index.js

@@ -1,3 +1 @@
-export { ResultCode } from './variable.js';
-export { getConfig, getConfigValue, onWatchConfigValue } from './config.js';
-export { createEventName, createHash, createResult, createUserHashKey, fastHash, getCachedRegExp, getInputExportPath, getRecursiveDirFiles, isMaster, matchIn, sanitizeForSerialization, showErrorModule, stringToNumber, useUserHashKey } from './utils.js';
+export { start } from './start.js';

package/lib/core/process/index.d.ts

@@ -0,0 +1,3 @@
+export * from './module.js';
+export * from './platform.js';
+export * from './ipc-bridge.js';

package/lib/{process → core/process}/index.js

@@ -1,4 +1,3 @@
 export { startModuleAdapter } from './module.js';
 export { startPlatformAdapterWithFallback } from './platform.js';
 export { forwardFromClient, forwardFromPlatform, getClientChild, getPlatformChild, setClientChild, setPlatformChild } from './ipc-bridge.js';
-export { createDirectClient, createDirectServer, generateSocketPath } from './direct-channel.js';

package/lib/{process → core/process}/ipc-bridge.js

@@ -4,7 +4,13 @@ import * as flattedJSON from 'flatted';
 import 'fs';
 import 'path';
 import 'yaml';
-import { sanitizeForSerialization } from '../core/utils.js';
+import '../../common/logger.js';
+import { sanitizeForSerialization } from '../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import '../../common/cbp/runtime.js';
+import { normalizeInboundMessage, isNormalizedActionRequest, toLegacyActionData, isNormalizedApiRequest, toLegacyApiData } from '../../common/cbp/normalize.js';
 
 let platformChild = null;
 let clientChild = null;
@@ -44,7 +50,15 @@ const forwardFromClient = (data) => {
     }
     if (global.__sandbox && global.testoneClient) {
         try {
-            const messageStr = typeof safeData === 'string' ? safeData : flattedJSON.stringify(safeData);
+            const normalized = normalizeInboundMessage(safeData);
+            let outbound = safeData;
+            if (isNormalizedActionRequest(normalized)) {
+                outbound = toLegacyActionData(normalized);
+            }
+            else if (isNormalizedApiRequest(normalized)) {
+                outbound = toLegacyApiData(normalized);
+            }
+            const messageStr = typeof outbound === 'string' ? outbound : flattedJSON.stringify(outbound);
             if (global.testoneClient.readyState === WebSocket.OPEN) {
                 global.testoneClient.send(messageStr);
             }

package/lib/{process → core/process}/module.js

@@ -1,7 +1,16 @@
 import childProcess from 'child_process';
-import { ResultCode } from '../core/variable.js';
-import { getConfigValue } from '../core/config.js';
-import '../core/utils.js';
+import { getConfigValue } from '../../common/config.js';
+import { ResultCode } from '../../common/variable.js';
+import '../../common/logger.js';
+import '../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import 'path';
+import 'fs';
+import 'flatted';
+import '../../common/cbp/runtime.js';
+import 'ws';
 import module$1 from 'module';
 import { setClientChild, forwardFromClient } from './ipc-bridge.js';
 
@@ -17,7 +26,7 @@ function startModuleAdapter() {
         FORK_TIMEOUT: pro?.fork_timeout ?? 6000
     };
     try {
-        modulePath = require$1.resolve('../client.js');
+        modulePath = require$1.resolve('../../client.js');
     }
     catch (error) {
         logger?.warn?.({

package/lib/{process → core/process}/platform.js

@@ -1,7 +1,16 @@
 import childProcess from 'child_process';
-import { ResultCode } from '../core/variable.js';
-import { getConfigValue } from '../core/config.js';
-import '../core/utils.js';
+import { getConfigValue } from '../../common/config.js';
+import { ResultCode } from '../../common/variable.js';
+import '../../common/logger.js';
+import '../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import 'path';
+import 'fs';
+import 'flatted';
+import '../../common/cbp/runtime.js';
+import 'ws';
 import module$1 from 'module';
 import { setPlatformChild, forwardFromPlatform } from './ipc-bridge.js';
 

package/lib/core/start.d.ts

@@ -0,0 +1,2 @@
+import type { StartOptions } from '../types';
+export declare const start: (options?: StartOptions | string) => void;