@meshflow/core 0.1.7 → 0.2.1

package/README.md

@@ -61,7 +61,7 @@ const engine = useMeshFlow<Ref<number,number>,AllPath>('main',schema, {
   //   useGreedy:true
   // },
   UITrigger:{//以vue为例
-    signalCreateor: () => ref(0),
+    signalCreator: () => ref(0),
     signalTrigger(signal) {
       signal.value++;
     },

package/index.d.mts

@@ -3,50 +3,67 @@ interface MeshErrorContext {
     error: any;
 }
 
+declare enum DefaultStarategy {
+    OR = "OR",
+    PRIORITY = "PRIORITY"
+}
+
+type Unwrap<T> = T extends ReadonlyArray<infer U> ? U : T;
+type InferLeafPath<T, Prefix extends string = ""> = Unwrap<T> extends infer Node ? Node extends {
+    readonly name: infer N;
+} ? N extends string ? N extends "" ? Node extends {
+    readonly children: infer C;
+} ? InferLeafPath<C, Prefix> : never : (Node extends {
+    readonly children: infer C;
+} ? InferLeafPath<C, Prefix extends "" ? N : `${Prefix}.${N}`> : (Prefix extends "" ? N : `${Prefix}.${N}`)) : N extends number | symbol ? Node extends {
+    readonly children: infer C;
+} ? InferLeafPath<C, Prefix> : N : never : never : never;
+type KeysOfUnion<T> = T extends any ? keyof T : never;
+
 interface MeshEvents {
     'node:start': {
-        path: string;
+        path: MeshPath;
     };
     'node:success': {
-        path: string;
+        path: MeshPath;
     };
     'node:bucket:success': {
-        path: string;
+        path: MeshPath;
         key: string;
         value: any;
     };
     'node:error': {
-        path: string;
+        path: MeshPath;
         error: any;
     };
     'node:intercept': {
-        path: string;
+        path: MeshPath;
         type: number;
         detail?: any;
     };
     'node:release': {
-        path: string;
+        path: MeshPath;
         type: number;
         detail?: any;
     };
     'node:stagnate': {
-        path: string;
+        path: MeshPath;
         type: number;
     };
     'node:processing': {
-        path: string;
+        path: MeshPath;
     };
     'flow:wait': {
         type: number;
         detail?: any;
     };
     'flow:fire': {
-        path: string;
+        path: MeshPath;
         type: number;
         detail?: any;
     };
     'flow:start': {
-        path: string;
+        path: MeshPath;
     };
     'flow:success': {
         duration: string;
@@ -55,165 +72,115 @@ interface MeshEvents {
         type: number;
     };
     'node:pending': {
-        path: string;
+        path: MeshPath;
     };
 }
 type MeshEventName = keyof MeshEvents;
-
-type ContractType = 'boolean' | 'scalar' | 'array' | 'object';
-declare enum DefaultStarategy {
-    OR = "OR",
-    PRIORITY = "PRIORITY"
-}
-declare class SchemaBucket<P> {
-    private path;
-    private strategy;
-    contract: ContractType;
-    private rules;
-    private isValue;
-    private id;
-    private cache;
-    private pendingPromise;
-    private version;
-    private deps;
-    private _forceNotify;
-    promiseToken: any;
-    private effectArray;
-    constructor(baseValue: any, key: string, path: P);
-    forceNotify(): void;
-    isForceNotify(): boolean;
-    setStrategy(type: DefaultStarategy): void;
-    updateInputValueRule(newVal: any): void;
-    setDefaultRule(value: any): void;
-    setRules(value: any, DepsArray?: Array<[P, any]>): () => void;
-    updateDeps(DepsArray: Array<[P, any]>): void;
-    setRule(value: any, DepsArray?: Array<[P, any]>): (() => void) | undefined;
-    setSideEffect(data: {
-        fn: (args: any[]) => any;
-        args: any[];
-    }): void;
-    getSideEffect(): {
-        fn: (args: any) => any;
-        args: any[];
-    }[];
-    evaluate(api: any): any;
-    private finalizeSync;
-    private inferType;
-}
-
-type FinalFlatten<T> = T extends infer O ? {
-    [K in keyof O]: O[K];
-} : never;
-type KeysOfUnion<T> = T extends any ? keyof T : never;
-
-type BaseField = {
-    label: string;
-    name: string;
-    placeholder?: string;
-    disabled: boolean;
-    readonly: boolean;
-    hidden?: boolean;
-    validators?: any;
-    theme?: string;
-};
-type InputField = BaseField & {
-    type: "input" | "number";
-    required: boolean;
-    min?: number;
-    maxLength: number;
-    value: string | number;
-};
-type CheckboxField = BaseField & {
-    type: "checkbox";
-    description?: string;
-    required: boolean;
-    value: boolean;
+type MeshEmit = <K extends MeshEventName>(event: K, data: MeshEvents[K]) => void;
+type HistoryActionItem = {
+    undoAction: () => void;
+    redoAction: () => void;
 };
-type SelectField = BaseField & {
-    type: "select";
-    required: boolean;
-    options: {
-        label: string;
-        value: any;
-    }[];
-    value: any;
-};
-type GroupField = Omit<BaseField, "label" | "name" | "placeholder" | "validators"> & {
-    type: "group";
-    name?: string;
-    children: FormFieldSchema[];
+type MeshFlowHistory = {
+    Undo: () => void;
+    Redo: () => void;
+    initCanUndo: any;
+    initCanRedo: any;
+    PushIntoHistory: (action: HistoryActionItem, cleanRedo?: boolean) => void;
+    CreateHistoryAction: (metadata: [
+        {
+            path: string;
+            value: any;
+        },
+        {
+            path: string;
+            value: any;
+        }
+    ], cb: any) => {
+        undoAction: () => any;
+        redoAction: () => any;
+    };
 };
-type FormFieldSchema = InputField | CheckboxField | SelectField | GroupField;
-type RenderSchemaExtraCommonType<P = any> = {
+interface MeshFlowEngineMap {
+}
+type MeshPath = string | number | symbol;
+interface MeshBucket<P> {
+    evaluate: (context: any) => Promise<any> | any;
+    [key: string]: any;
+}
+interface MeshFlowTaskNode<P extends MeshPath = MeshPath, V = any, S = any> {
     path: P;
+    uid: number;
+    type: string;
+    state: {
+        value: V;
+    };
+    nodeBucket: Record<keyof S, MeshBucket<P>>;
+    notifyKeys: Set<keyof S>;
     dirtySignal: any;
+    meta: S;
+    dependOn: (cb: (val: V) => V) => void;
+    createView: (extraProps?: Record<string, any>) => any;
+}
+interface MeshFlowGroupNode<P extends MeshPath = MeshPath> {
+    path: P;
     uid: number;
-    nodeBucket: Record<string, SchemaBucket<P>>;
-    dependOn: (cb: (...args: any) => void) => void;
-};
-type RenderSchemaFn<T> = FinalFlatten<T extends GroupField ? Omit<T, "children"> & RenderSchemaExtraCommonType & {
-    children: Array<RenderSchemaFn<FormFieldSchema>>;
-} : T & RenderSchemaExtraCommonType>;
-type RenderSchema = RenderSchemaFn<FormFieldSchema>;
-
+    type: 'group';
+    children: Array<P>;
+    dirtySignal: any;
+    meta: Record<string, any>;
+}
+interface DependOnContext<P extends MeshPath> {
+    path: P;
+    getNode: (path: P) => MeshFlowTaskNode<P>;
+}
 interface logicApi {
     slot: {
         triggerTargets: any;
         affectedTatget: any;
     };
 }
+interface SetRuleOptions<NM> {
+    value?: any;
+    priority?: number;
+    forceNotify?: boolean;
+    logic: (api: logicApi) => any;
+    effect?: (args: any) => any;
+    effectArgs?: Array<KeysOfUnion<NM>>;
+}
 
-type GetType<T, P> = P extends keyof T ? T[P] : never;
-type Engine<T> = {
-    data: {
-        [K in "schema" | "GetFormData" | "AddNewSchema" | 'SetValue' | 'GetValue' | 'GetGroupByPath']: GetType<T, K>;
-    };
+/**
+ * 🌟 入口函数
+ * @template T - UI 信号类型 (Signal)
+ * @template P - 路径联合类型 ("user.name" | "user.age") 也支持number或者symbol
+ * @template S - 业务元数据类型 (默认使用表单的 Meta，但也允许传入 any)
+ */
+declare function useEngineInstance<T, P extends MeshPath, S = any, NM = any>(data: S, options: {
     config: {
-        [K in "SetRule" | "SetRules" | "SetStrategy" | "SetValidators" | "notifyAll" | "SetTrace" | "usePlugin"]: GetType<T, K>;
-    };
-    dependency: {
-        [K in 'GetAllDependency' | 'GetDependencyOrder']: GetType<T, K>;
-    };
-    history: {
-        [K in "Undo" | "Redo" | "initCanUndo" | "initCanRedo"]: GetType<T, K>;
-    };
-    hooks: {
-        [K in "onError" | "onSuccess" | "onStart"]: GetType<T, K>;
-    };
-};
-/** @deprecated 请使用新的 useMeshFlow 别名 */
-declare const useEngineManager: <T, P extends string>(id: string | symbol, Schema: any, options: {
-    config?: {
         useGreedy: boolean;
     };
     UITrigger: {
-        signalCreateor: () => T;
+        signalCreator: () => T;
         signalTrigger: (signal: T) => void;
     };
-}) => Engine<{
-    schema: RenderSchema;
-    SetRule: (outDegreePath: P, inDegreePath: P, key: KeysOfUnion<InputField | CheckboxField | SelectField>, options?: {
-        value?: any;
-        priority?: number;
-        forceNotify?: boolean;
-        logic: (api: logicApi) => any;
-        effect?: ((args: any) => any) | undefined;
-        effectArgs?: Array<KeysOfUnion<Exclude<FormFieldSchema, GroupField>>>;
-    } | undefined) => void;
-    SetRules: (outDegreePaths: P[], inDegreePath: P, key: KeysOfUnion<InputField | CheckboxField | SelectField>, options?: {
-        value?: any;
-        priority?: number;
-        forceNotify?: boolean;
-        logic: (api: logicApi) => any;
-        effect?: ((args: any) => any) | undefined;
-        effectArgs?: Array<KeysOfUnion<Exclude<FormFieldSchema, GroupField>>>;
-    } | undefined) => void;
-    SetStrategy: (path: unknown, key: KeysOfUnion<Exclude<FormFieldSchema, GroupField>>, strategy: DefaultStarategy) => void;
-    SetValidators: (path: P, options: {
-        logic: (val: any, GetByPath: any) => any;
-        condition: (data: any) => boolean;
-    }) => void;
-    SetTrace: (myPath: P, onUpdate: (newStatus: "idle" | "pending" | "calculating" | "calculated" | "error" | "canceled") => void) => () => void;
+    modules: {
+        useHistory?: () => MeshFlowHistory;
+        useInternalForm?: <T, P>(scheduler: any, data: any) => any;
+        useSchemaValidators?: <P>(Finder: (path: P) => any) => {
+            SetValidators: (path: P, options: {
+                logic: (val: any, GetByPath: any) => any;
+                condition: (data: any) => boolean;
+            }) => void;
+        };
+    };
+    plugins: {};
+}): {
+    SetRule: <K extends KeysOfUnion<NM>>(outDegreePath: P, inDegreePath: P, key: K, options: SetRuleOptions<NM>) => void;
+    SetRules: <K extends KeysOfUnion<NM>>(outDegreePaths: P[], inDegreePath: P, key: K, options: SetRuleOptions<NM>) => void;
+    SetStrategy: (path: P, key: KeysOfUnion<NM>, strategy: DefaultStarategy) => void;
+    SetTrace: (myPath: P, onUpdate: (newStatus: "idle" | "pending" | "calculating" | "calculated" | "error" | "canceled") => void) => {
+        cancel: () => void;
+    };
     usePlugin: (plugin: {
         apply: (api: {
             on: (event: MeshEventName, cb: Function) => () => boolean;
@@ -221,46 +188,108 @@ declare const useEngineManager: <T, P extends string>(id: string | symbol, Schem
     }) => () => void;
     SetValue: (path: P, value: any) => void;
     GetValue: (path: P, key?: string) => any;
-    GetFormData: () => any;
-    GetGroupByPath: (path: string) => RenderSchema | undefined;
+    GetGroupByPath: (path: MeshPath) => MeshFlowGroupNode<MeshPath> | undefined;
     notifyAll: () => Promise<void>;
-    AddNewSchema: (path: string, data: any) => RenderSchema;
     GetAllDependency: () => Map<P, Set<P>>;
     GetDependencyOrder: () => P[][];
-    Undo: () => void;
-    Redo: () => void;
-    initCanUndo: (cb: (newVal: number) => any) => void;
-    initCanRedo: (cb: (newVal: number) => any) => void;
+    historyExports: Partial<MeshFlowHistory>;
+    formExports: {};
+    validatorExports: {
+        SetValidators?: (path: P, options: {
+            logic: (val: any, GetByPath: any) => any;
+            condition: (data: any) => boolean;
+        }) => void;
+    };
     onError: (cb: (error: MeshErrorContext) => void) => () => void;
     onSuccess: (cb: (data: unknown) => void) => () => void;
     onStart: (cb: (data: {
         path: P;
     }) => void) => () => void;
-}>;
-declare const useEngine: <T = any, P extends string = string>(id: string | symbol) => Engine<{
-    schema: RenderSchema;
-    SetRule: (outDegreePath: P, inDegreePath: P, key: KeysOfUnion<InputField | CheckboxField | SelectField>, options?: {
-        value?: any;
-        priority?: number;
-        forceNotify?: boolean;
-        logic: (api: logicApi) => any;
-        effect?: ((args: any) => any) | undefined;
-        effectArgs?: Array<KeysOfUnion<Exclude<FormFieldSchema, GroupField>>>;
-    } | undefined) => void;
-    SetRules: (outDegreePaths: P[], inDegreePath: P, key: KeysOfUnion<InputField | CheckboxField | SelectField>, options?: {
-        value?: any;
-        priority?: number;
-        forceNotify?: boolean;
-        logic: (api: logicApi) => any;
-        effect?: ((args: any) => any) | undefined;
-        effectArgs?: Array<KeysOfUnion<Exclude<FormFieldSchema, GroupField>>>;
-    } | undefined) => void;
-    SetStrategy: (path: unknown, key: KeysOfUnion<Exclude<FormFieldSchema, GroupField>>, strategy: DefaultStarategy) => void;
+};
+
+type SchedulerType<T, P extends MeshPath, S, NM> = ReturnType<typeof useEngineInstance<T, P, S, NM>>;
+type BaseEngine<T> = {
+    data: {
+        SetValue: T extends {
+            SetValue: infer F;
+        } ? F : never;
+        GetValue: T extends {
+            GetValue: infer F;
+        } ? F : never;
+        GetGroupByPath: T extends {
+            GetGroupByPath: infer F;
+        } ? F : never;
+    };
+    config: {
+        SetRule: T extends {
+            SetRule: infer F;
+        } ? F : never;
+        SetRules: T extends {
+            SetRules: infer F;
+        } ? F : never;
+        SetStrategy: T extends {
+            SetStrategy: infer F;
+        } ? F : never;
+        notifyAll: T extends {
+            notifyAll: infer F;
+        } ? F : never;
+        SetTrace: T extends {
+            SetTrace: infer F;
+        } ? F : never;
+        usePlugin: T extends {
+            usePlugin: infer F;
+        } ? F : never;
+    };
+    dependency: {
+        GetAllDependency: T extends {
+            GetAllDependency: infer F;
+        } ? F : never;
+        GetDependencyOrder: T extends {
+            GetDependencyOrder: infer F;
+        } ? F : never;
+    };
+    hooks: {
+        onError: T extends {
+            onError: infer F;
+        } ? F : never;
+        onSuccess: T extends {
+            onSuccess: infer F;
+        } ? F : never;
+        onStart: T extends {
+            onStart: infer F;
+        } ? F : never;
+    };
+};
+type TransformModuleKey<T> = T extends `use${infer Rest}` ? Uncapitalize<Rest> : T;
+type MapModuleToReturn<K, F, P extends MeshPath> = K extends 'useSchemaValidators' | 'schemaValidators' ? {
     SetValidators: (path: P, options: {
-        logic: (val: any, GetByPath: any) => any;
+        logic: (val: any, GetByPath: (path: P) => any) => any;
         condition: (data: any) => boolean;
     }) => void;
-    SetTrace: (myPath: P, onUpdate: (newStatus: "idle" | "pending" | "calculating" | "calculated" | "error" | "canceled") => void) => () => void;
+} : F extends (...args: any) => infer R ? R : any;
+type EngineModules<M, P extends MeshPath> = {
+    [K in keyof M as TransformModuleKey<string & K>]: MapModuleToReturn<K, M[K], P>;
+};
+type Engine<T, M, P extends MeshPath> = BaseEngine<T> & EngineModules<M, P>;
+/** @deprecated 请使用新的 useMeshFlow 别名 */
+declare const useEngineManager: <const S extends Record<string, any>, T, //UITrigger的类型
+M extends Record<string, any>, NM extends Record<string, any> = Record<string, any>, P extends MeshPath = [InferLeafPath<S>] extends [never] ? MeshPath : InferLeafPath<S> | (string & {})>(id: MeshPath, Schema: S, options: {
+    metaType?: NM;
+    config?: {
+        useGreedy: boolean;
+    };
+    modules?: M;
+    UITrigger: {
+        signalCreator: () => T;
+        signalTrigger: (signal: T) => void;
+    };
+}) => Engine<{
+    SetRule: <K extends KeysOfUnion<NM>>(outDegreePath: P, inDegreePath: P, key: K, options: SetRuleOptions<NM>) => void;
+    SetRules: <K extends KeysOfUnion<NM>>(outDegreePaths: P[], inDegreePath: P, key: K, options: SetRuleOptions<NM>) => void;
+    SetStrategy: (path: P, key: KeysOfUnion<NM>, strategy: DefaultStarategy) => void;
+    SetTrace: (myPath: P, onUpdate: (newStatus: "idle" | "pending" | "calculating" | "calculated" | "error" | "canceled") => void) => {
+        cancel: () => void;
+    };
     usePlugin: (plugin: {
         apply: (api: {
             on: (event: MeshEventName, cb: Function) => () => boolean;
@@ -268,55 +297,57 @@ declare const useEngine: <T = any, P extends string = string>(id: string | symbo
     }) => () => void;
     SetValue: (path: P, value: any) => void;
     GetValue: (path: P, key?: string) => any;
-    GetFormData: () => any;
-    GetGroupByPath: (path: string) => RenderSchema | undefined;
+    GetGroupByPath: (path: MeshPath) => MeshFlowGroupNode<MeshPath> | undefined;
     notifyAll: () => Promise<void>;
-    AddNewSchema: (path: string, data: any) => RenderSchema;
     GetAllDependency: () => Map<P, Set<P>>;
     GetDependencyOrder: () => P[][];
-    Undo: () => void;
-    Redo: () => void;
-    initCanUndo: (cb: (newVal: number) => any) => void;
-    initCanRedo: (cb: (newVal: number) => any) => void;
+    historyExports: Partial<MeshFlowHistory>;
+    formExports: {};
+    validatorExports: {
+        SetValidators?: ((path: P, options: {
+            logic: (val: any, GetByPath: any) => any;
+            condition: (data: any) => boolean;
+        }) => void) | undefined;
+    };
     onError: (cb: (error: MeshErrorContext) => void) => () => void;
     onSuccess: (cb: (data: unknown) => void) => () => void;
     onStart: (cb: (data: {
         path: P;
     }) => void) => () => void;
-}>;
-declare const deleteEngine: (id: string | symbol) => void;
-declare const useMeshFlow: <T, P extends string>(id: string | symbol, Schema: any, options: {
+}, M, P>;
+declare const useMeshFlowDefiner: <P extends MeshPath, NM extends Record<string, any> = any>() => <T, M extends Record<string, any>>(id: MeshPath, schema: any, options: {
+    metaType?: NM;
+    UITrigger: {
+        signalCreator: () => T;
+        signalTrigger: (s: T) => void;
+    };
+    modules?: M;
+    config?: any;
+}) => Engine<SchedulerType<T, P, any, NM>, M, P>;
+/**
+ * 获取 Engine 实例
+ * @template M 手动注入的模块映射 (例如 { useHistory: typeof useHistory })
+ * @template P ID 类型 (支持 string | number | symbol)
+ */
+declare const useEngine: <M, P extends MeshPath = any, NM = any, S = any, ID extends keyof MeshFlowEngineMap | (MeshPath & {}) = MeshPath>(id: ID) => [M] extends [never] ? (ID extends keyof MeshFlowEngineMap ? MeshFlowEngineMap[ID] : Engine<SchedulerType<any, any, any, any>, {}, P>) : Engine<SchedulerType<any, P, S, NM>, M, P>;
+declare const deleteEngine: (id: MeshPath) => void;
+declare const useMeshFlow: <const S extends Record<string, any>, T, M extends Record<string, any>, NM extends Record<string, any> = Record<string, any>, P extends MeshPath = [InferLeafPath<S>] extends [never] ? MeshPath : InferLeafPath<S> | (string & {})>(id: MeshPath, Schema: S, options: {
+    metaType?: NM;
     config?: {
         useGreedy: boolean;
     };
+    modules?: M;
     UITrigger: {
-        signalCreateor: () => T;
+        signalCreator: () => T;
         signalTrigger: (signal: T) => void;
     };
 }) => Engine<{
-    schema: RenderSchema;
-    SetRule: (outDegreePath: P, inDegreePath: P, key: KeysOfUnion<InputField | CheckboxField | SelectField>, options?: {
-        value?: any;
-        priority?: number;
-        forceNotify?: boolean;
-        logic: (api: logicApi) => any;
-        effect?: ((args: any) => any) | undefined;
-        effectArgs?: Array<KeysOfUnion<Exclude<FormFieldSchema, GroupField>>>;
-    } | undefined) => void;
-    SetRules: (outDegreePaths: P[], inDegreePath: P, key: KeysOfUnion<InputField | CheckboxField | SelectField>, options?: {
-        value?: any;
-        priority?: number;
-        forceNotify?: boolean;
-        logic: (api: logicApi) => any;
-        effect?: ((args: any) => any) | undefined;
-        effectArgs?: Array<KeysOfUnion<Exclude<FormFieldSchema, GroupField>>>;
-    } | undefined) => void;
-    SetStrategy: (path: unknown, key: KeysOfUnion<Exclude<FormFieldSchema, GroupField>>, strategy: DefaultStarategy) => void;
-    SetValidators: (path: P, options: {
-        logic: (val: any, GetByPath: any) => any;
-        condition: (data: any) => boolean;
-    }) => void;
-    SetTrace: (myPath: P, onUpdate: (newStatus: "idle" | "pending" | "calculating" | "calculated" | "error" | "canceled") => void) => () => void;
+    SetRule: <K extends KeysOfUnion<NM>>(outDegreePath: P, inDegreePath: P, key: K, options: SetRuleOptions<NM>) => void;
+    SetRules: <K extends KeysOfUnion<NM>>(outDegreePaths: P[], inDegreePath: P, key: K, options: SetRuleOptions<NM>) => void;
+    SetStrategy: (path: P, key: KeysOfUnion<NM>, strategy: DefaultStarategy) => void;
+    SetTrace: (myPath: P, onUpdate: (newStatus: "idle" | "pending" | "calculating" | "calculated" | "error" | "canceled") => void) => {
+        cancel: () => void;
+    };
     usePlugin: (plugin: {
         apply: (api: {
             on: (event: MeshEventName, cb: Function) => () => boolean;
@@ -324,21 +355,23 @@ declare const useMeshFlow: <T, P extends string>(id: string | symbol, Schema: an
     }) => () => void;
     SetValue: (path: P, value: any) => void;
     GetValue: (path: P, key?: string) => any;
-    GetFormData: () => any;
-    GetGroupByPath: (path: string) => RenderSchema | undefined;
+    GetGroupByPath: (path: MeshPath) => MeshFlowGroupNode<MeshPath> | undefined;
     notifyAll: () => Promise<void>;
-    AddNewSchema: (path: string, data: any) => RenderSchema;
     GetAllDependency: () => Map<P, Set<P>>;
     GetDependencyOrder: () => P[][];
-    Undo: () => void;
-    Redo: () => void;
-    initCanUndo: (cb: (newVal: number) => any) => void;
-    initCanRedo: (cb: (newVal: number) => any) => void;
+    historyExports: Partial<MeshFlowHistory>;
+    formExports: {};
+    validatorExports: {
+        SetValidators?: ((path: P, options: {
+            logic: (val: any, GetByPath: any) => any;
+            condition: (data: any) => boolean;
+        }) => void) | undefined;
+    };
     onError: (cb: (error: MeshErrorContext) => void) => () => void;
     onSuccess: (cb: (data: unknown) => void) => () => void;
     onStart: (cb: (data: {
         path: P;
     }) => void) => () => void;
-}>;
+}, M, P>;
 
-export { deleteEngine, useEngine, useEngineManager, useMeshFlow };
+export { type DependOnContext, type HistoryActionItem, type MeshBucket, type MeshEmit, type MeshEventName, type MeshEvents, type MeshFlowEngineMap, type MeshFlowGroupNode, type MeshFlowHistory, type MeshFlowTaskNode, type MeshPath, type SetRuleOptions, deleteEngine, type logicApi, useEngine, useEngineManager, useMeshFlow, useMeshFlowDefiner };