miniprogram-ci 2.1.32 → 2.1.34

package/dist/@types/build-server/tasks/common/utils/tracing/Trace.d.ts

@@ -0,0 +1,50 @@
+export interface IEvent {
+    name: string;
+    cat: string;
+    ph: string;
+    ts: number;
+    pid: number;
+    tid: number;
+    args: any;
+    [key: string]: any;
+}
+export default class Trace {
+    private _processes;
+    constructor(events?: IEvent[]);
+    addEvent(event: IEvent): void;
+    rmEvent(event: IEvent): void;
+    getProcess(id: number): Process;
+    rmProcess(id: number): void;
+    processes(): Process[];
+    toJSON(): IEvent[];
+}
+declare class Process {
+    private _id;
+    private _name;
+    private _threads;
+    private _metadata;
+    constructor(id: number);
+    id(): number;
+    name(): string;
+    addEvent(event: IEvent): void;
+    rmEvent(event: IEvent): void;
+    getThread(id: number): Thread;
+    rmThread(id: number): void;
+    threads(): Thread[];
+    toJSON(): IEvent[];
+}
+declare class Thread {
+    private _id;
+    private _pid;
+    private _name;
+    private _events;
+    private _metadata;
+    constructor(id: number, pid: number);
+    id(): number;
+    name(): string;
+    addEvent(event: IEvent): void;
+    rmEvent(event: IEvent): void;
+    events(): IEvent[];
+    toJSON(): IEvent[];
+}
+export {};

package/dist/@types/build-server/tasks/common/utils/tracing/aegis.d.ts

@@ -0,0 +1,3 @@
+export declare function error(message: string): void;
+export declare function info(message: string): void;
+export declare function reportTime(name: string, duration: number): void;

package/dist/@types/build-server/tasks/common/utils/tracing/index.d.ts

@@ -0,0 +1,34 @@
+declare class Tracing {
+    private pid;
+    private tid;
+    private processName;
+    private threadName;
+    private traceEventStack?;
+    private targetCat?;
+    private traceEventMap?;
+    private _trace?;
+    constructor({ pid, tid, processName, threadName, }?: {
+        pid?: number | undefined;
+        tid?: number | undefined;
+        processName?: string | undefined;
+        threadName?: string | undefined;
+    });
+    start(cat?: string): void;
+    stop(action?: (args: any) => void): import("./Trace").IEvent[] | undefined;
+    metadata(name: string, args: any, extra: any): void;
+    complete(cat: string, name: string, begin: number, end: number, args?: any): void;
+    begin(cat: string, name: string, args?: any): void;
+    end(args?: any): void;
+    asyncBegin(cat: string, name: string, id?: string, args?: {}, extra?: any): string;
+    asyncEnd(id: string, args?: {}): void;
+    instant(cat: string, name: string, scope?: string, args?: any): void;
+    traceAsyncFn<T extends FN>(asyncFn: T, cat: string, name: string, args?: any): T;
+    traceFn<T extends FN>(fn: T, cat: string, name: string, args?: any): T;
+    traceAsyncMethod(cat: string, name?: string, args?: any): (target: AnyObject, propertyKey: string, descriptor: PropertyDescriptor) => void;
+    traceMethod(cat: string, name?: string, args?: any): (target: AnyObject, propertyKey: string, descriptor: PropertyDescriptor) => void;
+    id(): string;
+    _addEvent(cat: string, name: string, ph: string, args?: {}, extra?: {}): void;
+    getCurTs(): number;
+}
+declare const tracing: Tracing;
+export default tracing;

package/dist/@types/build-server/tasks/common/utils/tracing/readiness.d.ts

@@ -0,0 +1,11 @@
+declare class Readiness {
+    private promises;
+    private resolves;
+    private states;
+    signal(tasks: string | string[]): void;
+    isReady(tasks: string | string[]): boolean;
+    ready(tasks: string | string[], fn?: FN): Promise<any>;
+    private getPromises;
+}
+declare const _default: Readiness;
+export default _default;

package/dist/@types/build-server/tasks/common/utils/tracing/report.d.ts

@@ -0,0 +1,14 @@
+declare class Report {
+    private reportStack;
+    private reportMap;
+    constructor();
+    complete(cat: string, name: string, dur: number): void;
+    begin(cat: string, name: string): void;
+    end(): void;
+    asyncBegin(cat: string, name: string, id: string, ts?: number): void;
+    asyncEnd(id: string): void;
+    private needToReport;
+    private report;
+}
+declare const _default: Report;
+export default _default;

package/dist/@types/build-server/tasks/common/utils/trans/transwxmltojs.d.ts

@@ -0,0 +1,28 @@
+import { IGlassEaselCompileResult } from '~/services/compilewxml/common/compilewxmlService';
+interface ITransWxmlOptions {
+    app?: boolean;
+    page?: string;
+    cut?: boolean;
+    hotReloadFile?: string;
+}
+interface IWXMLReturn {
+    name: string;
+    comm?: string;
+    code: string;
+    names?: AnyObject;
+    pages?: AnyObject;
+}
+type ITransWXMLResult = IWXMLReturn & {
+    glassEasel?: IGlassEaselCompileResult & {
+        commonTemplateResults: Record<string, string>;
+    };
+};
+declare function transWXMLToJS(project: IProject, options?: ITransWxmlOptions): Promise<IWXMLReturn>;
+declare function getWxmlJSOfComponent(project: IProject, options: ITransWxmlOptions): Promise<ITransWXMLResult>;
+declare function transWXMLToJSWithGlassEaselLazyload(project: IProject, options?: ITransWxmlOptions): Promise<ITransWXMLResult>;
+declare const _default: {
+    transWXMLToJS: typeof transWXMLToJS;
+    transWXMLToJSLazyload: typeof transWXMLToJSWithGlassEaselLazyload;
+    getWxmlJSOfComponent: typeof getWxmlJSOfComponent;
+};
+export = _default;

package/dist/@types/build-server/tasks/common/utils/transformsourcemap.d.ts

@@ -0,0 +1 @@
+export declare function transformSourceMapSources(sources?: Array<string | null> | undefined | null): Array<string | null>;

package/dist/@types/build-server/tasks/common/utils/web/glasseaselUtils.d.ts

@@ -0,0 +1 @@
+export declare const checkIsUseGlassEasel: (project: IProject) => Promise<boolean>;

package/dist/@types/build-server/tasks/common/utils/web/md5.d.ts

@@ -0,0 +1,2 @@
+import crypto = require('crypto');
+export declare function generateMD5(string: crypto.BinaryLike): string;

package/dist/@types/build-server/tasks/common/utils/web/processPath.d.ts

@@ -0,0 +1,9 @@
+interface INormalizePathOptions {
+    leading?: string;
+    noLeading?: string;
+    trailing?: string;
+    noTrailing?: string;
+}
+export declare function normalizePath(pathName?: string, options?: INormalizePathOptions): string;
+export declare function isLeftSubPathOfRight(child: string, parent: string): boolean;
+export {};

package/dist/@types/build-server/tasks/common/weapp.config.d.ts

@@ -0,0 +1,108 @@
+declare const c: {
+    readonly setting: any;
+    MAX_PAGE_STACK_DEPTH: number;
+    DEFAULT_NAVIGATIONBAR_WHITE_TEXTCOLOR: string;
+    DEFAULT_NAVIGATIONBAR_BLACK_TEXTCOLOR: string;
+    DEFAULT_NAVIGATIONBAR_BGCOLOR: string;
+    default_tabBarBorderBlackColor: string;
+    default_tabBarBorderWhiteColor: string;
+    default_backgroundColor: string;
+    default_android_singlepage_foot_height: number;
+    default_ios_singlepage_foot_height: number;
+    default_android_tabbar_height: number;
+    default_ios_tabbar_height: number;
+    default_android_navigationbar_height: number;
+    default_ios_navigationbar_height: number;
+    default_statusbar_height: number;
+    default_search_widget_radio: number;
+    default_conversation_widget_radio: number;
+    default_titlebar_height: number;
+    NO_BOM_VAR: string[];
+    readonly whiteFileExtName: {
+        [key: string]: boolean;
+    };
+    readonly gameWhiteFileExtName: {
+        [key: string]: boolean;
+    };
+    errorPrefix: {
+        COMPONENT_FOR_DEVELOPER: string;
+        WXML_RUNTIME_ERROR: string;
+        WXML_RUNTIME_ERROR_REG: RegExp;
+        WXML_PLUGIN_RUNTIME_ERROR_REG: RegExp;
+        WXS_RUNTIME_ERROR: string;
+        WEBVIEW_ERROR: string;
+        CODE_ERROR: string;
+    };
+    weappURLRegular: RegExp;
+    weappASURLRegular: RegExp;
+    weappLocalIdRegular: RegExp;
+    weappEditorServiceRegular: RegExp;
+    weappPluginServiceRegular: RegExp;
+    weappGamePageRegular: RegExp;
+    weappTraceRegular: RegExp;
+    weappSCFDebugRegular: RegExp;
+    weappSCFLongPollRegular: RegExp;
+    SCENE_DEFAULT: number;
+    SCENE_SINGLE_SHARE: number;
+    SCENE_GROUP_SHARE: number;
+    SCENE_PROFILE: number;
+    SCENE_CUSTOM_MENU: number;
+    SCENE_APP_SHARE_MESSAGE: number;
+    SCENE_MINI_PROGRAM: number;
+    SCENE_MINI_PROGRAM_BACK: number;
+    SCENE_TEMPLETE_MESSAGE: number;
+    SCENE_SHARE_TICKET: number;
+    SCENE_MOBILE_APPLICATION: number;
+    SCENE_GEOGRAPHIC_INFO: number;
+    SCENE_GROUP_TOOLBAR: number;
+    SCENE_GROUP_UPCOMING: number;
+    SCENE_CHAT_MATERIAL: number;
+    SCENE_H5_OPEN: number;
+    SCENE_SINGLE_MODE_OPEN: number;
+    APP_TYPE: {
+        NORMAL: number;
+        PLUGIN: number;
+        SHOP: number;
+        MINISHOP: number;
+        GAME: number;
+        CARD: number;
+        NATIVE: number;
+    };
+    DEBUGGER_FILE: {
+        AS_SUB_LOADER: string;
+        WORKER: string;
+        WORKER_AS_DEBUG: string;
+        SUB_AS_DEBUG: string;
+        AS_DEBUG: string;
+    };
+    DEFAULT_ATTR_INFO: {
+        network: {
+            RequestDomain: never[];
+            WsRequestDomain: never[];
+            UploadDomain: never[];
+            DownloadDomain: never[];
+            UDPDomain: never[];
+            TCPDomain: never[];
+            BizDomain: never[];
+        };
+        appImageUrl: string;
+        appName: string;
+        appType: number;
+        minPublicLibVersion: string;
+        platform: boolean;
+        released: boolean;
+        gameApp: boolean;
+        isSandbox: boolean;
+        hasMobile: boolean;
+        adminName: string;
+        sendQbaseConfirmMsgLimit: boolean;
+        share_info: never[];
+        isExtAppId: boolean;
+        authQY: boolean;
+        permissionBitset: string;
+        userbanded: boolean;
+        username: string;
+        readonly setting: any;
+    };
+};
+export = c;

package/dist/@types/build-server/tasks/pageInitSourceCompile/index.d.ts

@@ -0,0 +1,2 @@
+export declare const getPageInitResource: (project: any, filepath: string) => Promise<string>;
+export declare const getPageInitResourceCore: (project: any, filepath: string) => Promise<string>;

package/dist/@types/build-server/tasks/pageframeCompile/index.d.ts

@@ -0,0 +1 @@
+export declare function getPageframeCore(project: IBackendProject, isMultiPkg?: boolean): Promise<string>;

package/dist/@types/build-server/tasks/pageframeCompile/utils/appdevserver/getwxappcode.d.ts

@@ -0,0 +1,8 @@
+interface IGetWxAppCodeOptions {
+    app?: boolean;
+    page?: string;
+    noJson?: boolean;
+    noWXSS?: boolean;
+}
+export declare function getPageFrameWxAppCode(project: IProject, options?: IGetWxAppCodeOptions): Promise<string>;
+export {};

package/dist/@types/build-server/tasks/pageframeCompile/utils/trans/transwxsstojs.d.ts

@@ -0,0 +1,26 @@
+interface ITransWxssOptions {
+    app?: boolean;
+    page?: string;
+    hotReloadFile?: string;
+}
+interface ITransWxssInnerOptions {
+    appConfig: DR<AppConfig.IAppConfig>;
+    config?: DR<AppConfig.ISubpackageItem>;
+    lazyload?: boolean;
+}
+interface IWxssReturn {
+    comm: string;
+    page?: string;
+}
+declare function getWxssFilesAndContent(project: IProject, options: ITransWxssInnerOptions): Promise<{
+    wxssFiles: string[];
+    content: Record<string, string>;
+}>;
+declare function transWXSSToJS(project: IProject, options?: ITransWxssOptions): Promise<IWxssReturn>;
+declare function transWXSSToJSLazyload(project: IProject, options?: ITransWxssOptions): Promise<IWxssReturn>;
+declare const _default: {
+    transWXSSToJS: typeof transWXSSToJS;
+    transWXSSToJSLazyload: typeof transWXSSToJSLazyload;
+    getWxssFilesAndContent: typeof getWxssFilesAndContent;
+};
+export = _default;

package/dist/@types/build-server/testAppConfig.d.ts

@@ -0,0 +1 @@
+import '~/services/root/server/rootService';

package/dist/@types/build-server/testAppservice.d.ts

@@ -0,0 +1 @@
+import '~/services/root/server/rootService';

package/dist/@types/build-server/testInitSourceCompile.d.ts

@@ -0,0 +1 @@
+import '~/services/root/server/rootService';

package/dist/@types/build-server/testPageframe.d.ts

@@ -0,0 +1 @@
+import '~/services/root/server/rootService';

package/dist/@types/build-server/testSubProcess.d.ts

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

package/dist/@types/build-server/utils/fileTask.d.ts

@@ -0,0 +1,5 @@
+import { MiniProgramDevtools } from '../../types';
+import type { IBuildFileTaskQueue, IBuildFileTaskList } from '../type';
+import { ResolveFileInfo } from '../../modules/corecompiler/summer/resolver';
+export declare function getSummerTaskConfig(setting: MiniProgramDevtools.IProjectSetting): IBuildFileTaskQueue[];
+export declare function generateFileTaskList(fileList: ResolveFileInfo[], taskConfig: IBuildFileTaskQueue[]): IBuildFileTaskList;

package/dist/@types/build-server/utils/getFileOrCache.d.ts

@@ -0,0 +1,24 @@
+export declare const getFileContent: (data: {
+    ticket: string;
+    projectId: string;
+    snapshotId: string;
+    versionId: string;
+    filePath: string;
+}) => Promise<{
+    code: number;
+    data: string;
+}>;
+export declare const getFileOrCache: (data: {
+    ticket: string;
+    projectId: string;
+    snapshotId: string;
+    versionId: string;
+    fileTask: {
+        filePath: string;
+        taskLinks: string[];
+    };
+}) => Promise<{
+    code: number;
+    isCacheResult?: boolean;
+    data: string;
+}>;

package/dist/@types/build-server/utils/request.d.ts

@@ -0,0 +1,47 @@
+export declare const getFileContentHTTP: (data: {
+    ticket: string;
+    projectId: string;
+    versionId: string;
+    snapshotId: string;
+    path: string | string[];
+}) => Promise<{
+    success: boolean;
+    fileList: {
+        name: string;
+        content: string;
+    }[];
+    message: string;
+}>;
+export declare const getProjectUpdateTimeHTTP: (data: {
+    projectId: string;
+    versionId: string;
+    snapshotId: string;
+    ticket: string;
+}) => Promise<{
+    success: boolean;
+    fileList: {
+        name: string;
+        key: string;
+        lastModifiedTime: number;
+        size: number;
+        createTime: number;
+    }[];
+    message: string;
+}>;
+export declare const getProjectUpdateTimeContentHTTP: (data: {
+    projectId: string;
+    versionId: string;
+    snapshotId: string;
+    ticket: string;
+}) => Promise<{
+    success: boolean;
+    fileList: {
+        name: string;
+        key: string;
+        lastModifiedTime: number;
+        size: number;
+        createTime: number;
+        content: string;
+    }[];
+    message: string;
+}>;

package/dist/@types/bussinessMonitor/monitor.d.ts

@@ -0,0 +1 @@
+export declare const BusinessReport: (module: string, action: string, data: string) => Promise<void>;

package/dist/@types/ci/cloud/utils.d.ts

@@ -8,7 +8,7 @@ interface IZipFileOptions {
     includeRoot?: boolean;
 }
 export declare const zipFile: (filePath: string, { ignore, name, zip, includeRoot }?: IZipFileOptions) => JSZip;
-export declare const zipToBuffer: (zip: JSZip, onUpdate?: any) => Promise<Buffer>;
+export declare const zipToBuffer: (zip: JSZip, onUpdate?: any) => Promise<Buffer<ArrayBufferLike>>;
 export declare function initEnvironmentByProject(project: MiniProgramCI.IProject, env: string): Promise<{
     currentEnv: IAPIEnvironment;
     cloudAPI: typeof cloudAPI;

package/dist/@types/common/code-analyse/index.d.ts

@@ -143,6 +143,7 @@ export declare class Graph {
     constructor(options: GraphOptions, prevGraph?: Graph);
     private processDep;
     private processDeps;
+    private waitFor1ms;
     private processTask;
     private run;
     private getModule;
@@ -182,6 +183,17 @@ declare interface GraphOptions {
     pluginDriver?: Analyzer;
 }
 
+declare interface IAgentConfig {
+    skills?: IAgentSkillConfig[];
+}
+
+declare interface IAgentSkillConfig {
+    name?: string;
+    description?: string;
+    path?: string;
+    [key: string]: unknown;
+}
+
 /**
  * @public
  */
@@ -193,6 +205,7 @@ export declare interface IAnalyseResult {
 
 declare interface IAppJSON {
     pages?: string[];
+    agent?: IAgentConfig;
     workers?: string | {
         path: string;
         isSubpackage: boolean;
@@ -324,6 +337,8 @@ export declare interface IPackageFile {
     size: number;
     moduleId: ModuleId | null;
     subPackage: string | null;
+    agentPackage: string | null;
+    packageType: 'subpackage' | 'agent' | null;
 }
 
 declare interface IPluginConfig {
@@ -383,6 +398,6 @@ export declare type ModuleId = string;
 /**
  * @public
  */
-export declare type ModuleType = 'Js' | 'Wxml' | 'Wxss' | 'Wxs' | 'Config' | 'MainPackage' | 'SubPackage' | 'WorkerSubPackage' | 'Page' | 'Component' | 'Plugin' | 'Worker' | 'FunctionalPages' | 'ContextModule' | 'PluginPackage' | 'GameMainPackage' | 'GameSubPackage';
+export declare type ModuleType = 'Js' | 'Wxml' | 'Wxss' | 'Wxs' | 'Agent' | 'Config' | 'MainPackage' | 'SubPackage' | 'WorkerSubPackage' | 'Page' | 'Component' | 'Plugin' | 'Worker' | 'FunctionalPages' | 'ContextModule' | 'PluginPackage' | 'GameMainPackage' | 'GameSubPackage';
 
 export { }

package/dist/@types/config/config.d.ts

@@ -1,5 +1,5 @@
 import { IProject } from '../types';
-export declare const CI_VERSION = "2.1.32";
+export declare const CI_VERSION = "2.1.34";
 export declare const PARAM_ERROR = 10000;
 export declare const WXML_NOT_FOUND = 10007;
 export declare const JS_NOT_FOUND = 10008;

package/dist/@types/modules/corecompiler/original/compile/game.d.ts

@@ -1,4 +1,4 @@
 import { MiniProgramCore } from '../../../../types';
 export declare function compile(project: MiniProgramCore.IPreCompileProject, options: MiniProgramCore.ICompileOptions): Promise<{
-    [x: string]: string | Buffer;
+    [x: string]: string | Buffer<ArrayBufferLike>;
 }>;

package/dist/@types/modules/corecompiler/original/compile/index.d.ts

@@ -1,4 +1,4 @@
 import { MiniProgramCore } from '../../../../types';
 export declare function compile(project: MiniProgramCore.IPreCompileProject, options: MiniProgramCore.ICompileOptions): Promise<{
-    [x: string]: string | Buffer;
+    [x: string]: string | Buffer<ArrayBufferLike>;
 }>;

package/dist/@types/modules/corecompiler/original/index.d.ts

@@ -42,7 +42,7 @@ export declare class OriginalCompileManager {
         map: string | import("source-map").RawSourceMap;
     }>;
     compile(options: MiniProgramCore.ICompileOptions): Promise<{
-        [x: string]: string | Buffer;
+        [x: string]: string | Buffer<ArrayBufferLike>;
     }>;
     clearCache: typeof clearCache;
     setLocale: (tag: string) => void;

package/dist/@types/modules/corecompiler/original/workerThread/childprocessManager.d.ts

@@ -6,7 +6,7 @@ export declare class ChildProcessCrashedError extends Error {
 declare class TaskManager {
     private _taskQueue;
     private _instance;
-    runTask(name: string, data: any, onStatusUpdate?: MiniProgramCore.FN<void>): Promise<unknown>;
+    runTask(name: string, data: any, onStatusUpdate?: MiniProgramCore.FN<void>): Promise<any>;
     private _run;
     private allocChildProcess;
     private onChildProcessExit;

package/dist/@types/modules/corecompiler/original/workerThread/config.d.ts

@@ -8,8 +8,11 @@ export declare const TASK_NAME: {
     COMPILE_WXSS: string;
     MINIFY_WXML: string;
     SUMMER_HOOK: string;
+    PIPE_TASK: string;
 };
 export declare const COMMAND: {
+    INIT_START: string;
+    INIT_READY: string;
     RUN_TASK: string;
     TASK_DONE: string;
     CALL_FUNC: string;

package/dist/@types/modules/corecompiler/original/workerThread/task/compilejs.d.ts

@@ -18,9 +18,12 @@ declare function compileJS(data: ICompileData): Promise<{
 } | {
     error: {
         path: string;
+    } | {
+        path: string;
         name: string;
         message: string;
         stack?: string;
+        code?: number | string;
     } | {
         path: string;
         message: string;

package/dist/@types/modules/corecompiler/original/workerThread/workerManager.d.ts

@@ -1,11 +1,19 @@
 import { MiniProgramCore } from '../../../../types';
+export interface IWorkerTaskRecord {
+    workerId: number | string;
+    taskName: string;
+    duration: number;
+}
 export declare const AbortEvent = "WorkerTaskAborted";
 declare class WorkerManager {
     private _taskQueue;
     private _workerPool;
     private _max_pool_size;
+    private _taskRecords;
     constructor(size: number, isDevtools?: boolean);
     runTask(name: string, data: any, onStatusUpdate?: MiniProgramCore.FN<void>): Promise<unknown>;
+    getTaskRecords(): IWorkerTaskRecord[];
+    clearTaskRecords(): void;
     abort(name: string): void;
     private _run;
     private getFreeWorker;

package/dist/@types/modules/corecompiler/originalCompiler.d.ts

@@ -40,7 +40,7 @@ export declare class OriginalCompiler extends BaseCoreCompiler {
         isPlugin?: boolean;
     }): Promise<import("../../types").ThemeJSON.IThemeJSON>;
     compile(options: MiniProgramCore.ICompileOptions): Promise<{
-        [x: string]: string | Buffer;
+        [x: string]: string | Buffer<ArrayBufferLike>;
     }>;
     compileJS(options: {
         root: string;

package/dist/@types/modules/corecompiler/summer/pipeManager/index.d.ts

@@ -0,0 +1,6 @@
+export { PipeManager } from './pipeManager';
+export { PipeCPProject } from './pipeCPProject';
+export { PipeContext } from './pipeContext';
+export { runPipeTask } from './pipeWorker';
+export { allPipes } from './pipes/index';
+export type { IPipeDefinition, IPipeContext, IPipeProjectSerializeInfo, IPipeRequest, IPipeResponse, IPipeTaskData, IPipeTaskResult, IExecutePipeData, } from './types';

package/dist/@types/modules/corecompiler/summer/pipeManager/pipeCPProject.d.ts

@@ -0,0 +1,17 @@
+import { BaseProject } from '../../../../project/baseProject';
+import { IPipeProjectSerializeInfo } from './types';
+import { MiniProgramCore } from '~/types';
+import type { IBackendContextFromWeb } from '~/types/type';
+export declare class PipeCPProject extends BaseProject {
+    backendProjectContext?: IBackendContextFromWeb;
+    projectContext?: {
+        projectId: string;
+        versionId: string;
+        ticket: string;
+        sessionId: string;
+    };
+    constructor(projectInfo: IPipeProjectSerializeInfo);
+    init(): void;
+    updateFileAndDirs(): void;
+    static serializeForPipe(project: MiniProgramCore.IPreCompileProject): Promise<IPipeProjectSerializeInfo>;
+}

package/dist/@types/modules/corecompiler/summer/pipeManager/pipeContext.d.ts

@@ -0,0 +1,10 @@
+import { PipeCPProject } from './pipeCPProject';
+import { IPipeContext, IPipeRequest, IPipeResponse } from './types';
+export declare class PipeContext implements IPipeContext {
+    project: PipeCPProject;
+    private sendRequest;
+    constructor(project: PipeCPProject, sendRequest: (req: IPipeRequest) => Promise<IPipeResponse>);
+    requestPipe<T = unknown>(pipeName: string, params?: Record<string, unknown>): Promise<T>;
+    callCompiler<T = unknown>(method: string, ...args: unknown[]): Promise<T>;
+    getService<T>(id: any): T;
+}

package/dist/@types/modules/corecompiler/summer/pipeManager/pipeManager.d.ts

@@ -0,0 +1,12 @@
+import { Recorder } from '../../../../utils/progressRecorder';
+import { SummerCompiler } from '../summer';
+import { IExecutePipeData, IPipeRequest } from './types';
+export declare class PipeManager {
+    private compiler;
+    constructor(compiler: SummerCompiler);
+    executePipe(data: IExecutePipeData, recorder: Recorder): Promise<any>;
+    handlePipeIPC(req: IPipeRequest, recorder: Recorder): Promise<any>;
+    destroy(): void;
+    private executeCompilerMethod;
+    private runPipeTask;
+}

package/dist/@types/modules/corecompiler/summer/pipeManager/pipeWorker.d.ts

@@ -0,0 +1,2 @@
+import { IPipeTaskData, IPipeTaskResult } from './types';
+export declare function runPipeTask(data: IPipeTaskData): Promise<IPipeTaskResult>;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/appservicePipe/index.d.ts

@@ -0,0 +1,3 @@
+import { IPipeContext, IPipeDefinition } from '../../types';
+export declare function getAppserviceCore(context: IPipeContext): Promise<string>;
+export declare const appservicePipe: IPipeDefinition;

package/dist/@types/modules/corecompiler/summer/pipeManager/pipes/compileWxmlToGlassEaselPipe.d.ts

@@ -0,0 +1,3 @@
+import { ICompileWxmlToGlassEasel } from '~/services/compilewxml/common/compilewxmlService';
+import { IPipeDefinition } from '../types';
+export declare const compileWxmlToGlassEaselPipe: IPipeDefinition<ICompileWxmlToGlassEasel>;