@qlover/fe-corekit 2.0.0 → 2.0.1

package/dist/index.js

@@ -2466,24 +2466,33 @@ var require_pick = __commonJS({
 // src/executor/interface/Executor.ts
 var Executor = /*#__PURE__*/ function() {
     "use strict";
-    function Executor(config) {
+    function Executor() {
+        var config = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
         _class_call_check(this, Executor);
         this.config = config;
         /**
-     * Array of active plugins
+     * Array of active plugins for this executor
+     *
+     * Core concept:
+     * Maintains an ordered collection of plugins that participate in the execution pipeline
      *
-     * - Purpose: Stores and manages executor plugins
-     * - Core Concept: Ordered plugin pipeline
-     * - Main Features:
-     *  - Maintains plugin execution order
-     *  - Supports plugin lifecycle management
-     * - Primary Use: Plugin orchestration and execution
+     * Main features:
+     * - Plugin storage: Stores all registered plugins in execution order
+     * - Lifecycle management: Manages plugin initialization and cleanup
+     * - Execution coordination: Ensures plugins execute in the correct sequence
+     * - Deduplication support: Prevents duplicate plugins when configured
+     *
+     * Plugin execution order:
+     * 1. Plugins are executed in the order they were added
+     * 2. Each plugin can modify data or control execution flow
+     * 3. Plugin hooks are called based on executor configuration
      *
      * @example
      * ```typescript
      * protected plugins = [
      *   new LoggerPlugin(),
-     *   new RetryPlugin()
+     *   new RetryPlugin({ maxAttempts: 3 }),
+     *   new CachePlugin({ ttl: 300 })
      * ];
      * ```
      */ this.plugins = [];
@@ -2491,33 +2500,56 @@ var Executor = /*#__PURE__*/ function() {
     _create_class(Executor, [
         {
             /**
-   * Add a plugin to the executor
+   * Add a plugin to the executor's execution pipeline
    *
-   * - Purpose: Extends executor functionality through plugins
-   * - Core Concept: Plugin registration and deduplication
-   * - Main Features:
-   *  - Prevents duplicate plugins if onlyOne is true
-   *  - Maintains plugin execution order
-   * - Primary Use: Adding new capabilities to executor
+   * Core concept:
+   * Registers a plugin to participate in the executor's execution pipeline,
+   * extending the executor's functionality with additional capabilities
    *
-   * @param plugin - Plugin instance to add
+   * Main features:
+   * - Plugin registration: Adds plugins to the execution pipeline
+   * - Deduplication: Prevents duplicate plugins when `onlyOne` is true
+   * - Order preservation: Maintains plugin execution order
+   * - Validation: Ensures plugin is a valid object
    *
-   * @example
+   * Deduplication logic:
+   * - Checks for exact plugin instance match
+   * - Checks for plugin name match
+   * - Checks for constructor match
+   * - Only prevents duplicates when `plugin.onlyOne` is true
+   *
+   * @param plugin - Plugin instance to add to the execution pipeline
+   *
+   * @throws {Error} When plugin is not a valid object
+   *
+   * @example Add a class-based plugin
    * ```typescript
    * executor.use(new LoggerPlugin());
    * executor.use(new RetryPlugin({ maxAttempts: 3 }));
    * ```
    *
-   * @example
-   *
-   * Use a plain object as a plugin
+   * @example Add a plain object plugin
    * ```typescript
    * executor.use({
-   *   onBefore: (data) => ({ ...data, modified: true })
+   *   pluginName: 'CustomPlugin',
+   *   onBefore: (data) => ({ ...data, modified: true }),
+   *   onAfter: (result) => console.log('Result:', result)
    * });
    * ```
+   *
+   * @example Plugin with deduplication
+   * ```typescript
+   * const plugin = new LoggerPlugin();
+   * plugin.onlyOne = true;
+   *
+   * executor.use(plugin); // First addition - succeeds
+   * executor.use(plugin); // Second addition - skipped with warning
+   * ```
    */ key: "use",
             value: function use(plugin) {
+                if ((typeof plugin === "undefined" ? "undefined" : _type_of(plugin)) !== "object" || plugin === null) {
+                    throw new Error("Plugin must be an object");
+                }
                 if (this.plugins.find(function(p) {
                     return p === plugin || p.pluginName === plugin.pluginName || p.constructor === plugin.constructor;
                 }) && plugin.onlyOne) {
@@ -2548,6 +2580,267 @@ var ExecutorError = /*#__PURE__*/ function _target(Error1) {
     }
     return ExecutorError;
 }(_wrap_native_super(Error));
+// src/executor/impl/ContextHandler.ts
+function createContext(parameters) {
+    return {
+        parameters: parameters,
+        returnValue: void 0,
+        error: void 0,
+        hooksRuntimes: {
+            pluginName: "",
+            hookName: "",
+            returnValue: void 0,
+            returnBreakChain: false,
+            times: 0,
+            breakChain: false,
+            index: void 0
+        }
+    };
+}
+var ContextHandler = /*#__PURE__*/ function() {
+    "use strict";
+    function ContextHandler() {
+        _class_call_check(this, ContextHandler);
+    }
+    _create_class(ContextHandler, [
+        {
+            /**
+   * Reset hooks runtime state to initial values
+   *
+   * Core concept:
+   * Clears all runtime tracking information for fresh execution
+   *
+   * Reset operations:
+   * - Clears plugin name and hook name
+   * - Resets return value and chain breaking flags
+   * - Resets execution counter and index
+   *
+   * @param hooksRuntimes - The hooks runtime object to reset
+   *
+   * @example
+   * ```typescript
+   * const handler = new ContextHandler();
+   * handler.resetHooksRuntimes(context.hooksRuntimes);
+   * ```
+   */ key: "resetHooksRuntimes",
+            value: function resetHooksRuntimes(hooksRuntimes) {
+                hooksRuntimes.pluginName = "";
+                hooksRuntimes.hookName = "";
+                hooksRuntimes.returnValue = void 0;
+                hooksRuntimes.returnBreakChain = false;
+                hooksRuntimes.times = 0;
+                hooksRuntimes.breakChain = false;
+                hooksRuntimes.index = void 0;
+            }
+        },
+        {
+            /**
+   * Reset entire context to initial state
+   *
+   * Core concept:
+   * Complete context cleanup for new execution cycle
+   *
+   * Reset operations:
+   * - Resets hooks runtime state
+   * - Clears return value
+   * - Clears error state
+   *
+   * @template Params - Type of context parameters
+   * @param context - The execution context to reset
+   *
+   * @example
+   * ```typescript
+   * const handler = new ContextHandler();
+   * handler.reset(context);
+   * ```
+   */ key: "reset",
+            value: function reset(context) {
+                this.resetHooksRuntimes(context.hooksRuntimes);
+                context.returnValue = void 0;
+                context.error = void 0;
+            }
+        },
+        {
+            /**
+   * Check if a plugin hook should be skipped
+   * Returns true if the hook should be skipped (invalid or disabled)
+   *
+   * Core concept:
+   * Plugin hook validation and enablement checking
+   *
+   * Validation criteria:
+   * - Hook method exists and is callable
+   * - Plugin is enabled for the specific hook
+   * - Plugin enablement function returns true
+   *
+   * @template Params - Type of context parameters
+   * @param plugin - The plugin to check
+   * @param hookName - The name of the hook to validate
+   * @param context - The execution context
+   * @returns True if the hook should be skipped, false otherwise
+   *
+   * @example
+   * ```typescript
+   * const shouldSkip = handler.shouldSkipPluginHook(
+   *   validationPlugin,
+   *   'onBefore',
+   *   context
+   * );
+   *
+   * if (!shouldSkip) {
+   *   // Execute the hook
+   * }
+   * ```
+   */ key: "shouldSkipPluginHook",
+            value: function shouldSkipPluginHook(plugin, hookName, context) {
+                return typeof plugin[hookName] !== "function" || typeof plugin.enabled == "function" && !plugin.enabled(hookName, context);
+            }
+        },
+        {
+            /**
+   * Update runtime tracking information for plugin execution
+   *
+   * Core concept:
+   * Track plugin execution metadata for debugging and flow control
+   *
+   * Tracking information:
+   * - Current plugin name
+   * - Current hook name
+   * - Execution counter (times)
+   * - Plugin index in execution chain
+   *
+   * @template Params - Type of context parameters
+   * @param context - The execution context
+   * @param plugin - The plugin being executed
+   * @param hookName - The hook name being executed
+   * @param index - The index of the plugin in the execution chain
+   *
+   * @example
+   * ```typescript
+   * handler.runtimes(context, plugin, 'onBefore', 0);
+   * ```
+   */ key: "runtimes",
+            value: function runtimes(context, plugin, hookName, index) {
+                context.hooksRuntimes.pluginName = plugin.pluginName;
+                context.hooksRuntimes.hookName = hookName;
+                context.hooksRuntimes.times = (context.hooksRuntimes.times || 0) + 1;
+                context.hooksRuntimes.index = index;
+            }
+        },
+        {
+            /**
+   * Set return value in context runtime tracking
+   *
+   * Core concept:
+   * Store plugin hook return value for chain control and debugging
+   *
+   * Usage scenarios:
+   * - Track plugin hook return values
+   * - Enable chain breaking based on return values
+   * - Debug plugin execution flow
+   *
+   * @template Params - Type of context parameters
+   * @param context - The execution context
+   * @param returnValue - The value to set as return value
+   *
+   * @example
+   * ```typescript
+   * const result = plugin.onBefore(context);
+   * handler.runtimeReturnValue(context, result);
+   * ```
+   */ key: "runtimeReturnValue",
+            value: function runtimeReturnValue(context, returnValue) {
+                context.hooksRuntimes.returnValue = returnValue;
+            }
+        },
+        {
+            /**
+   * Check if the execution chain should be broken
+   *
+   * Core concept:
+   * Chain breaking control for plugin execution flow
+   *
+   * Chain breaking scenarios:
+   * - Plugin explicitly sets breakChain flag
+   * - Error conditions requiring immediate termination
+   * - Business logic requiring early exit
+   *
+   * @template Params - Type of context parameters
+   * @param context - The execution context
+   * @returns True if the chain should be broken, false otherwise
+   *
+   * @example
+   * ```typescript
+   * if (handler.shouldBreakChain(context)) {
+   *   break; // Stop plugin execution
+   * }
+   * ```
+   */ key: "shouldBreakChain",
+            value: function shouldBreakChain(context) {
+                var _context_hooksRuntimes;
+                return !!((_context_hooksRuntimes = context.hooksRuntimes) === null || _context_hooksRuntimes === void 0 ? void 0 : _context_hooksRuntimes.breakChain);
+            }
+        },
+        {
+            /**
+   * Check if the execution chain should be broken due to return value
+   *
+   * Core concept:
+   * Return value-based chain breaking control
+   *
+   * Usage scenarios:
+   * - Plugin returns a value that should terminate execution
+   * - Error handling hooks return error objects
+   * - Business logic requires return value-based flow control
+   *
+   * @template Params - Type of context parameters
+   * @param context - The execution context
+   * @returns True if the chain should be broken due to return value, false otherwise
+   *
+   * @example
+   * ```typescript
+   * if (handler.shouldBreakChainOnReturn(context)) {
+   *   return context.hooksRuntimes.returnValue;
+   * }
+   * ```
+   */ key: "shouldBreakChainOnReturn",
+            value: function shouldBreakChainOnReturn(context) {
+                var _context_hooksRuntimes;
+                return !!((_context_hooksRuntimes = context.hooksRuntimes) === null || _context_hooksRuntimes === void 0 ? void 0 : _context_hooksRuntimes.returnBreakChain);
+            }
+        },
+        {
+            /**
+   * Set error in context
+   *
+   * Core concept:
+   * Error state management for execution context
+   *
+   * Error handling:
+   * - Store error for plugin error hooks
+   * - Enable error-based flow control
+   * - Support error propagation through plugin chain
+   *
+   * @template Params - Type of context parameters
+   * @param context - The execution context
+   * @param error - The error to set in context
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   // Execute some operation
+   * } catch (error) {
+   *   handler.setError(context, error as Error);
+   * }
+   * ```
+   */ key: "setError",
+            value: function setError(context, error) {
+                context.error = error;
+            }
+        }
+    ]);
+    return ContextHandler;
+}();
 // src/executor/impl/AsyncExecutor.ts
 var AsyncExecutor = /*#__PURE__*/ function(Executor) {
     "use strict";
@@ -2555,56 +2848,64 @@ var AsyncExecutor = /*#__PURE__*/ function(Executor) {
     var _super = _create_super(AsyncExecutor);
     function AsyncExecutor() {
         _class_call_check(this, AsyncExecutor);
-        return _super.apply(this, arguments);
+        var _this;
+        _this = _super.call.apply(_super, [
+            this
+        ].concat(Array.prototype.slice.call(arguments)));
+        _this.contextHandler = new ContextHandler();
+        return _this;
     }
     _create_class(AsyncExecutor, [
         {
-            key: "runHooks",
+            key: "runHook",
             value: /**
-   * Execute plugin hook functions asynchronously
+   * Execute a single plugin hook function asynchronously
    *
-   * - Purpose: Orchestrates asynchronous plugin hook execution
-   * - Core Concept: Sequential async plugin pipeline
-   * - Main Features:
-   *  - Plugin enablement checking
-   *  - Result chaining
-   *  - Error hook special handling
-   * - Primary Use: Internal plugin lifecycle management
+   * Core concept:
+   * Sequential async plugin execution with chain breaking and return value handling
    *
-   * Plugin execution flow:
+   * Execution flow:
    * 1. Check if plugin is enabled for the hook
    * 2. Execute plugin hook if available
    * 3. Handle plugin results and chain breaking conditions
+   * 4. Continue to next plugin or break chain
+   *
+   * Key features:
+   * - Plugin enablement checking
+   * - Chain breaking support
+   * - Return value management
+   * - Runtime tracking
+   * - Async execution with await
    *
    * @param plugins - Array of plugins to execute
    * @param hookName - Name of the hook function to execute
-   * @param args - Arguments to pass to the hook function
-   * @returns Promise resolving to the hook execution result
+   * @param context - Execution context containing data and runtime information
+   * @param args - Additional arguments to pass to the hook function
+   * @returns Promise resolving to the result of the hook function execution
+   * @since 2.1.0
    *
-   * @example
+   * @example Internal usage
    * ```typescript
    * const result = await this.runHook(
    *   this.plugins,
-   *   'beforeExec',
-   *   { userId: 123 }
+   *   'onBefore',
+   *   context,
+   *   data
    * );
    * ```
-   */ function runHooks(plugins, hookName, context) {
+   */ function runHook(plugins, hookName, context) {
                 for(var _len = arguments.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++){
                     args[_key - 3] = arguments[_key];
                 }
+                var _this = this;
                 return _async_to_generator(function() {
-                    var _index, returnValue, _context, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, plugin, _plugin, _context_hooksRuntimes, pluginReturn, err;
+                    var _index, returnValue, _context, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, plugin, _plugin, pluginReturn, err;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
                                 _index = -1;
-                                _context = context || {
-                                    parameters: void 0,
-                                    hooksRuntimes: {}
-                                };
-                                _context.hooksRuntimes.times = 0;
-                                _context.hooksRuntimes.index = void 0;
+                                _context = context || createContext({});
+                                _this.contextHandler.resetHooksRuntimes(_context.hooksRuntimes);
                                 _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                                 _state.label = 1;
                             case 1:
@@ -2623,34 +2924,31 @@ var AsyncExecutor = /*#__PURE__*/ function(Executor) {
                                 ];
                                 plugin = _step.value;
                                 _index++;
-                                if (typeof plugin[hookName] !== "function" || typeof plugin.enabled == "function" && !plugin.enabled(hookName, context)) {
+                                if (_this.contextHandler.shouldSkipPluginHook(plugin, hookName, _context)) {
                                     return [
                                         3,
                                         4
                                     ];
                                 }
-                                if ((_context_hooksRuntimes = _context.hooksRuntimes) === null || _context_hooksRuntimes === void 0 ? void 0 : _context_hooksRuntimes.breakChain) {
+                                if (_this.contextHandler.shouldBreakChain(_context)) {
                                     return [
                                         3,
                                         5
                                     ];
                                 }
-                                _context.hooksRuntimes.pluginName = plugin.pluginName;
-                                _context.hooksRuntimes.hookName = hookName;
-                                _context.hooksRuntimes.times++;
-                                _context.hooksRuntimes.index = _index;
+                                _this.contextHandler.runtimes(_context, plugin, hookName, _index);
                                 return [
                                     4,
                                     (_plugin = plugin)[hookName].apply(_plugin, [
-                                        context
+                                        _context
                                     ].concat(_to_consumable_array(args)))
                                 ];
                             case 3:
                                 pluginReturn = _state.sent();
                                 if (pluginReturn !== void 0) {
                                     returnValue = pluginReturn;
-                                    _context.hooksRuntimes.returnValue = pluginReturn;
-                                    if (_context.hooksRuntimes.returnBreakChain) {
+                                    _this.contextHandler.runtimeReturnValue(_context, pluginReturn);
+                                    if (_this.contextHandler.shouldBreakChainOnReturn(_context)) {
                                         return [
                                             2,
                                             returnValue
@@ -2700,25 +2998,168 @@ var AsyncExecutor = /*#__PURE__*/ function(Executor) {
                 })();
             }
         },
+        {
+            key: "runHooks",
+            value: /**
+   * Execute multiple plugin hook functions asynchronously
+   * Supports executing multiple hook names in sequence
+   *
+   * Core concept:
+   * Sequential execution of multiple hooks with chain breaking support
+   *
+   * Execution flow:
+   * 1. For each hook name, check if plugin is enabled
+   * 2. Execute plugin hook if available
+   * 3. Handle plugin results and chain breaking conditions
+   * 4. Continue to next hook name if chain is not broken
+   *
+   * Key features:
+   * - Supports multiple hook names in sequence
+   * - Chain breaking support for each hook
+   * - Return value management across hooks
+   * - Backward compatibility with single hook execution
+   * - Async execution with await
+   *
+   * @param plugins - Array of plugins to execute
+   * @param hookNames - Single hook name or array of hook names to execute in sequence
+   * @param context - Execution context containing data and runtime information
+   * @param args - Additional arguments to pass to the hook functions
+   * @returns Promise resolving to the result of the last executed hook function
+   *
+   * @example Execute multiple hooks in sequence
+   * ```typescript
+   * const result = await this.runHooks(
+   *   this.plugins,
+   *   ['onBefore', 'onValidate', 'onProcess'],
+   *   context,
+   *   data
+   * );
+   * ```
+   *
+   * @example Execute single hook (backward compatibility)
+   * ```typescript
+   * const result = await this.runHooks(
+   *   this.plugins,
+   *   'onBefore',
+   *   context,
+   *   data
+   * );
+   * ```
+   */ function runHooks(plugins, hookNames, context) {
+                for(var _len = arguments.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++){
+                    args[_key - 3] = arguments[_key];
+                }
+                var _this = this;
+                return _async_to_generator(function() {
+                    var hookNameArray, lastReturnValue, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, hookName, result, err;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                hookNameArray = Array.isArray(hookNames) ? hookNames : [
+                                    hookNames
+                                ];
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    6,
+                                    7,
+                                    8
+                                ]);
+                                _iterator = hookNameArray[Symbol.iterator]();
+                                _state.label = 2;
+                            case 2:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    5
+                                ];
+                                hookName = _step.value;
+                                return [
+                                    4,
+                                    _this.runHook.apply(_this, [
+                                        plugins,
+                                        hookName,
+                                        context
+                                    ].concat(_to_consumable_array(args)))
+                                ];
+                            case 3:
+                                result = _state.sent();
+                                if (result !== void 0) {
+                                    lastReturnValue = result;
+                                }
+                                if (context && _this.contextHandler.shouldBreakChain(context)) {
+                                    return [
+                                        3,
+                                        5
+                                    ];
+                                }
+                                _state.label = 4;
+                            case 4:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    2
+                                ];
+                            case 5:
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 6:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 7:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 8:
+                                return [
+                                    2,
+                                    lastReturnValue
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
         {
             key: "execNoError",
             value: /**
    * Execute task without throwing errors
    *
-   * - Purpose: Safe execution of async tasks
-   * - Core Concept: Error wrapping and handling
-   * - Main Features:
-   *  - Catches all execution errors
-   *  - Wraps errors in ExecutorError
-   *  - Returns either result or error object
-   * - Primary Use: When you want to handle errors without try-catch
+   * Core concept:
+   * Error-safe execution pipeline that returns errors instead of throwing
    *
-   * @template T - Type of task return value
+   * Advantages over try-catch:
+   * - Standardized error handling
+   * - No exception propagation
+   * - Consistent error types
+   * - Plugin error handling support
+   *
+   * @template Result - Type of task return value
+   * @template Params - Type of task input parameters
    * @param dataOrTask - Task data or task function
-   * @param task - Task function (optional)
-   * @returns Promise resolving to either result or ExecutorError
+   * @param task - Task function (optional when dataOrTask is a function)
+   * @returns Promise resolving to task result or ExecutorError if execution fails
    *
-   * @example
+   * @throws Never throws - all errors are wrapped in ExecutorError
+   *
+   * @example Basic usage
    * ```typescript
    * const result = await executor.execNoError(async () => {
    *   const response = await riskyOperation();
@@ -2729,6 +3170,14 @@ var AsyncExecutor = /*#__PURE__*/ function(Executor) {
    *   console.error('Operation failed:', result);
    * }
    * ```
+   *
+   * @example With input data
+   * ```typescript
+   * const result = await executor.execNoError(
+   *   { userId: 123 },
+   *   async (data) => await fetchUserData(data.userId)
+   * );
+   * ```
    */ function execNoError(dataOrTask, task) {
                 var _this = this;
                 return _async_to_generator(function() {
@@ -2776,37 +3225,52 @@ var AsyncExecutor = /*#__PURE__*/ function(Executor) {
             /**
    * Execute asynchronous task with full plugin pipeline
    *
-   * - Purpose: Primary method for executing async tasks
-   * - Core Concept: Full plugin pipeline execution
-   * - Main Features:
-   *  - Plugin hook integration
-   *  - Task validation
-   *  - Custom execution support
-   * - Primary Use: Running async tasks with plugin support
+   * Core concept:
+   * Complete execution pipeline with plugin lifecycle management
    *
    * Execution flow:
    * 1. Validate and prepare task
-   * 2. Check for custom execution plugins
-   * 3. Execute task with plugin pipeline
+   * 2. Execute beforeHooks (configured or default 'onBefore')
+   * 3. Execute core task logic with execHook support
+   * 4. Execute afterHooks (configured or default 'onSuccess')
+   * 5. Handle errors with onError hooks if needed
    *
-   * @template T - Type of task return value
-   * @template D - Type of task data
+   * Performance considerations:
+   * - Async overhead for Promise handling
+   * - Sequential execution path
+   * - Plugin chain optimization
+   *
+   * @template Result - Type of task return value
+   * @template Params - Type of task input parameters
    * @param dataOrTask - Task data or task function
-   * @param task - Task function (optional)
+   * @param task - Task function (optional when dataOrTask is a function)
    * @throws {Error} When task is not an async function
-   * @returns Promise resolving to task result
+   * @throws {ExecutorError} When task execution fails
+   * @returns Promise resolving to task execution result
    *
-   * @example
+   * @example Basic task execution
+   * ```typescript
+   * const result = await executor.exec(async (data) => {
+   *   const response = await fetch('https://api.example.com/data');
+   *   return response.json();
+   * });
+   * ```
+   *
+   * @example With input data
    * ```typescript
-   * // With separate data and task
    * const data = { userId: 123 };
    * const result = await executor.exec(data, async (input) => {
    *   return await fetchUserData(input.userId);
    * });
+   * ```
    *
-   * // With combined task
-   * const result = await executor.exec(async () => {
-   *   return await fetchData();
+   * @example With validation
+   * ```typescript
+   * const result = await executor.exec(async (data) => {
+   *   if (typeof data !== 'string') {
+   *     throw new Error('Data must be string');
+   *   }
+   *   return await processData(data);
    * });
    * ```
    */ key: "exec",
@@ -2819,105 +3283,121 @@ var AsyncExecutor = /*#__PURE__*/ function(Executor) {
                 return this.run(data, actualTask);
             }
         },
+        {
+            key: "runExec",
+            value: /**
+   * Execute core task logic with execHook support
+   *
+   * Core concept:
+   * Handles the execution phase with optional plugin intervention
+   *
+   * Execution logic:
+   * 1. Execute configured execHook (default: 'onExec')
+   * 2. If no execHook was executed, run the actual task
+   * 3. Otherwise, use the return value from execHook
+   *
+   * @template Result - Type of task return value
+   * @template Params - Type of task input parameters
+   * @param context - Execution context
+   * @param actualTask - Task function to execute
+   */ function runExec(context, actualTask) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var _this_config, execHook, _tmp;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                execHook = ((_this_config = _this.config) === null || _this_config === void 0 ? void 0 : _this_config.execHook) || "onExec";
+                                return [
+                                    4,
+                                    _this.runHook(_this.plugins, execHook, context, actualTask)
+                                ];
+                            case 1:
+                                _state.sent();
+                                if (!!context.hooksRuntimes.times) return [
+                                    3,
+                                    3
+                                ];
+                                return [
+                                    4,
+                                    actualTask(context)
+                                ];
+                            case 2:
+                                _tmp = _state.sent();
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 3:
+                                _tmp = context.hooksRuntimes.returnValue;
+                                _state.label = 4;
+                            case 4:
+                                context.returnValue = _tmp;
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
         {
             key: "run",
             value: /**
    * Core task execution method with plugin hooks
    *
-   * - Purpose: Implements the complete execution pipeline
-   * - Core Concept: Sequential hook execution with error handling
-   * - Main Features:
-   *  - Before/After hooks
-   *  - Error handling hooks
-   *  - Result transformation
-   * - Primary Use: Internal pipeline orchestration
+   * Core concept:
+   * Complete execution pipeline with configurable hook lifecycle
    *
    * Pipeline stages:
-   * 1. onBefore hooks - Pre-process input data
-   * 2. Task execution - Run the actual task
-   * 3. onSuccess hooks - Post-process results
+   * 1. beforeHooks - Pre-process input data (configurable, default: 'onBefore')
+   * 2. Task execution - Run the actual task with execHook support
+   * 3. afterHooks - Post-process results (configurable, default: 'onSuccess')
    * 4. onError hooks - Handle any errors
    *
-   * @template T - Type of task return value
-   * @template D - Type of task data
-   * @param data - Input data for the task
-   * @param actualTask - Task function to execute
+   * Error handling strategy:
+   * - Catches all errors
+   * - Passes errors through plugin chain
+   * - Wraps unhandled errors in ExecutorError
+   * - Supports plugin error handling
+   *
+   * @template Result - Type of task return value
+   * @template Params - Type of task input parameters
+   * @param data - Data to pass to the task
+   * @param actualTask - Actual task function to execute
    * @throws {ExecutorError} When task execution fails
-   * @returns Promise resolving to task result(context.returnValue)
+   * @returns Promise resolving to task execution result
    *
-   * @example
+   * @example Internal implementation
    * ```typescript
-   * private async run(data, task) {
+   * protected async run(data, task) {
    *   try {
-   *     const preparedData = await this.runHook(this.plugins, 'onBefore', data);
-   *     const result = await task(preparedData);
-   *     return await this.runHook(this.plugins, 'onSuccess', result);
+   *     // Execute beforeHooks (configurable)
+   *     await this.runHooks(this.plugins, beforeHooks, context);
+   *
+   *     // Execute core logic with execHook support
+   *     await this.runExec(context, actualTask);
+   *
+   *     // Execute afterHooks (configurable)
+   *     await this.runHooks(this.plugins, afterHooks, context);
+   *
+   *     return context.returnValue;
    *   } catch (error) {
-   *     const handledError = await this.runHook(
-   *       this.plugins,
-   *       'onError',
-   *       error,
-   *       data
-   *     );
-   *     throw new ExecutorError('EXECUTION_FAILED', handledError);
+   *     // Handle errors with onError hooks
+   *     await this.runHook(this.plugins, 'onError', context);
    *   }
    * }
    * ```
    */ function run(data, actualTask) {
                 var _this = this;
                 return _async_to_generator(function() {
-                    var context, runExec, error;
+                    var _this_config, _this_config1, context, beforeHooks, afterHooks, error;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
-                                context = {
-                                    parameters: data,
-                                    returnValue: void 0,
-                                    error: void 0,
-                                    hooksRuntimes: {
-                                        pluginName: "",
-                                        hookName: "",
-                                        returnValue: void 0,
-                                        returnBreakChain: false,
-                                        times: 0
-                                    }
-                                };
-                                runExec = function() {
-                                    var _ref = _async_to_generator(function(ctx) {
-                                        return _ts_generator(this, function(_state) {
-                                            switch(_state.label){
-                                                case 0:
-                                                    return [
-                                                        4,
-                                                        _this.runHooks(_this.plugins, "onExec", ctx, actualTask)
-                                                    ];
-                                                case 1:
-                                                    _state.sent();
-                                                    if (!(ctx.hooksRuntimes.times === 0)) return [
-                                                        3,
-                                                        3
-                                                    ];
-                                                    return [
-                                                        4,
-                                                        actualTask(ctx)
-                                                    ];
-                                                case 2:
-                                                    ctx.returnValue = _state.sent();
-                                                    return [
-                                                        2
-                                                    ];
-                                                case 3:
-                                                    ctx.returnValue = ctx.hooksRuntimes.returnValue;
-                                                    return [
-                                                        2
-                                                    ];
-                                            }
-                                        });
-                                    });
-                                    return function runExec(ctx) {
-                                        return _ref.apply(this, arguments);
-                                    };
-                                }();
+                                context = createContext(data);
+                                beforeHooks = ((_this_config = _this.config) === null || _this_config === void 0 ? void 0 : _this_config.beforeHooks) || "onBefore";
+                                afterHooks = ((_this_config1 = _this.config) === null || _this_config1 === void 0 ? void 0 : _this_config1.afterHooks) || "onSuccess";
                                 _state.label = 1;
                             case 1:
                                 _state.trys.push([
@@ -2928,19 +3408,19 @@ var AsyncExecutor = /*#__PURE__*/ function(Executor) {
                                 ]);
                                 return [
                                     4,
-                                    _this.runHooks(_this.plugins, "onBefore", context)
+                                    _this.runHooks(_this.plugins, beforeHooks, context)
                                 ];
                             case 2:
                                 _state.sent();
                                 return [
                                     4,
-                                    runExec(context)
+                                    _this.runExec(context, actualTask)
                                 ];
                             case 3:
                                 _state.sent();
                                 return [
                                     4,
-                                    _this.runHooks(_this.plugins, "onSuccess", context)
+                                    _this.runHooks(_this.plugins, afterHooks, context)
                                 ];
                             case 4:
                                 _state.sent();
@@ -2950,28 +3430,22 @@ var AsyncExecutor = /*#__PURE__*/ function(Executor) {
                                 ];
                             case 5:
                                 error = _state.sent();
-                                context.error = error;
+                                _this.contextHandler.setError(context, error);
                                 return [
                                     4,
-                                    _this.runHooks(_this.plugins, "onError", context)
+                                    _this.runHook(_this.plugins, "onError", context)
                                 ];
                             case 6:
                                 _state.sent();
                                 if (context.hooksRuntimes.returnValue) {
-                                    context.error = context.hooksRuntimes.returnValue;
+                                    _this.contextHandler.setError(context, context.hooksRuntimes.returnValue);
                                 }
                                 if (_instanceof(context.error, ExecutorError)) {
                                     throw context.error;
                                 }
                                 throw new ExecutorError("UNKNOWN_ASYNC_ERROR", context.error);
                             case 7:
-                                context.hooksRuntimes = {
-                                    pluginName: "",
-                                    hookName: "",
-                                    returnValue: void 0,
-                                    returnBreakChain: false,
-                                    times: 0
-                                };
+                                _this.contextHandler.reset(context);
                                 return [
                                     7
                                 ];
@@ -2994,75 +3468,78 @@ var SyncExecutor = /*#__PURE__*/ function(Executor) {
     var _super = _create_super(SyncExecutor);
     function SyncExecutor() {
         _class_call_check(this, SyncExecutor);
-        return _super.apply(this, arguments);
+        var _this;
+        _this = _super.call.apply(_super, [
+            this
+        ].concat(Array.prototype.slice.call(arguments)));
+        _this.contextHandler = new ContextHandler();
+        return _this;
     }
     _create_class(SyncExecutor, [
         {
             /**
-   * Execute plugin hook functions synchronously
-   * Manages the plugin execution chain and handles results
+   * Execute a single plugin hook function synchronously
+   *
+   * Core concept:
+   * Sequential plugin execution with chain breaking and return value handling
    *
-   * Plugin execution flow:
+   * Execution flow:
    * 1. Check if plugin is enabled for the hook
    * 2. Execute plugin hook if available
    * 3. Handle plugin results and chain breaking conditions
+   * 4. Continue to next plugin or break chain
    *
-   * Key differences from AsyncExecutor:
-   * - All operations are synchronous
-   * - Results are immediately available
-   * - No await statements needed
+   * Key features:
+   * - Plugin enablement checking
+   * - Chain breaking support
+   * - Return value management
+   * - Runtime tracking
    *
    * @param plugins - Array of plugins to execute
    * @param hookName - Name of the hook function to execute
-   * @param args - Arguments to pass to the hook function
+   * @param context - Execution context containing data and runtime information
+   * @param args - Additional arguments to pass to the hook function
    * @returns Result of the hook function execution
+   * @since 2.1.0
    *
-   * @example
+   * @example Internal usage
    * ```typescript
-   * // Internal usage example
    * const result = this.runHook(
    *   this.plugins,
    *   'onBefore',
-   *   { value: 'test' }
+   *   context,
+   *   data
    * );
    * ```
-   */ key: "runHooks",
-            value: function runHooks(plugins, hookName, context) {
+   */ key: "runHook",
+            value: function runHook(plugins, hookName, context) {
                 for(var _len = arguments.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++){
                     args[_key - 3] = arguments[_key];
                 }
                 var _index = -1;
                 var returnValue;
-                var _context = context || {
-                    parameters: void 0,
-                    hooksRuntimes: {}
-                };
-                _context.hooksRuntimes.times = 0;
-                _context.hooksRuntimes.index = void 0;
+                var _context = context || createContext({});
+                this.contextHandler.resetHooksRuntimes(_context.hooksRuntimes);
                 var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                 try {
                     for(var _iterator = plugins[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                         var plugin = _step.value;
                         var _plugin;
-                        var _context_hooksRuntimes;
                         _index++;
-                        if (typeof plugin[hookName] !== "function" || typeof plugin.enabled == "function" && !plugin.enabled(hookName, _context)) {
+                        if (this.contextHandler.shouldSkipPluginHook(plugin, hookName, _context)) {
                             continue;
                         }
-                        if ((_context_hooksRuntimes = _context.hooksRuntimes) === null || _context_hooksRuntimes === void 0 ? void 0 : _context_hooksRuntimes.breakChain) {
+                        if (this.contextHandler.shouldBreakChain(_context)) {
                             break;
                         }
-                        _context.hooksRuntimes.pluginName = plugin.pluginName;
-                        _context.hooksRuntimes.hookName = hookName;
-                        _context.hooksRuntimes.times++;
-                        _context.hooksRuntimes.index = _index;
+                        this.contextHandler.runtimes(_context, plugin, hookName, _index);
                         var pluginReturn = (_plugin = plugin)[hookName].apply(_plugin, [
-                            context
+                            _context
                         ].concat(_to_consumable_array(args)));
                         if (pluginReturn !== void 0) {
                             returnValue = pluginReturn;
-                            _context.hooksRuntimes.returnValue = pluginReturn;
-                            if (_context.hooksRuntimes.returnBreakChain) {
+                            this.contextHandler.runtimeReturnValue(_context, pluginReturn);
+                            if (this.contextHandler.shouldBreakChainOnReturn(_context)) {
                                 return returnValue;
                             }
                         }
@@ -3086,20 +3563,114 @@ var SyncExecutor = /*#__PURE__*/ function(Executor) {
         },
         {
             /**
+   * Execute multiple plugin hook functions synchronously
+   * Supports executing multiple hook names in sequence
+   *
+   * Core concept:
+   * Sequential execution of multiple hooks with chain breaking support
+   *
+   * Execution flow:
+   * 1. For each hook name, check if plugin is enabled
+   * 2. Execute plugin hook if available
+   * 3. Handle plugin results and chain breaking conditions
+   * 4. Continue to next hook name if chain is not broken
+   *
+   * Key features:
+   * - Supports multiple hook names in sequence
+   * - Chain breaking support for each hook
+   * - Return value management across hooks
+   * - Backward compatibility with single hook execution
+   *
+   * @param plugins - Array of plugins to execute
+   * @param hookNames - Single hook name or array of hook names to execute in sequence
+   * @param context - Execution context containing data and runtime information
+   * @param args - Additional arguments to pass to the hook functions
+   * @returns Result of the last executed hook function
+   *
+   * @example Execute multiple hooks in sequence
+   * ```typescript
+   * const result = this.runHooks(
+   *   this.plugins,
+   *   ['onBefore', 'onValidate', 'onProcess'],
+   *   context,
+   *   data
+   * );
+   * ```
+   *
+   * @example Execute single hook (backward compatibility)
+   * ```typescript
+   * const result = this.runHooks(
+   *   this.plugins,
+   *   'onBefore',
+   *   context,
+   *   data
+   * );
+   * ```
+   */ key: "runHooks",
+            value: function runHooks(plugins, hookNames, context) {
+                for(var _len = arguments.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++){
+                    args[_key - 3] = arguments[_key];
+                }
+                var hookNameArray = Array.isArray(hookNames) ? hookNames : [
+                    hookNames
+                ];
+                var lastReturnValue;
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = hookNameArray[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var hookName = _step.value;
+                        var result = this.runHook.apply(this, [
+                            plugins,
+                            hookName,
+                            context
+                        ].concat(_to_consumable_array(args)));
+                        if (result !== void 0) {
+                            lastReturnValue = result;
+                        }
+                        if (context && this.contextHandler.shouldBreakChain(context)) {
+                            break;
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return lastReturnValue;
+            }
+        },
+        {
+            /**
    * Execute task without throwing errors
    * Wraps all errors in ExecutorError for safe error handling
    *
+   * Core concept:
+   * Error-safe execution pipeline that returns errors instead of throwing
+   *
    * Advantages over try-catch:
-   * 1. Standardized error handling
-   * 2. No exception propagation
-   * 3. Consistent error types
+   * - Standardized error handling
+   * - No exception propagation
+   * - Consistent error types
+   * - Plugin error handling support
    *
-   * @template T - Type of task return value
+   * @template Result - Type of task return value
+   * @template Params - Type of task input parameters
    * @param dataOrTask - Task data or task function
-   * @param task - Task function (optional)
-   * @returns Task result or ExecutorError
+   * @param task - Task function (optional when dataOrTask is a function)
+   * @returns Task result or ExecutorError if execution fails
    *
-   * @example
+   * @throws Never throws - all errors are wrapped in ExecutorError
+   *
+   * @example Basic usage
    * ```typescript
    * const result = executor.execNoError((data) => {
    *   if (!data.isValid) {
@@ -3114,6 +3685,14 @@ var SyncExecutor = /*#__PURE__*/ function(Executor) {
    *   console.log('Task succeeded:', result);
    * }
    * ```
+   *
+   * @example With input data
+   * ```typescript
+   * const result = executor.execNoError(
+   *   { value: 'test' },
+   *   (data) => data.value.toUpperCase()
+   * );
+   * ```
    */ key: "execNoError",
             value: function execNoError(dataOrTask, task) {
                 try {
@@ -3131,34 +3710,49 @@ var SyncExecutor = /*#__PURE__*/ function(Executor) {
    * Execute synchronous task with full plugin pipeline
    * Core method for task execution with plugin support
    *
+   * Core concept:
+   * Complete execution pipeline with plugin lifecycle management
+   *
    * Execution flow:
    * 1. Validate and prepare task
-   * 2. Check for custom execution plugins
-   * 3. Execute task with plugin pipeline
+   * 2. Execute beforeHooks (configured or default 'onBefore')
+   * 3. Execute core task logic with execHook support
+   * 4. Execute afterHooks (configured or default 'onSuccess')
+   * 5. Handle errors with onError hooks if needed
    *
    * Performance considerations:
    * - No async overhead
    * - Direct execution path
    * - Immediate results
+   * - Plugin chain optimization
    *
-   * @template T - Type of task return value
-   * @template D - Type of task data
+   * @template Result - Type of task return value
+   * @template Params - Type of task input parameters
    * @param dataOrTask - Task data or task function
-   * @param task - Task function (optional)
+   * @param task - Task function (optional when dataOrTask is a function)
    * @throws {Error} When task is not a function
+   * @throws {ExecutorError} When task execution fails
    * @returns Task execution result
    *
-   * @example
+   * @example Basic task execution
+   * ```typescript
+   * const result = executor.exec((data) => {
+   *   return data.toUpperCase();
+   * });
+   * ```
+   *
+   * @example With input data
    * ```typescript
-   * // Example with data transformation
    * const data = { numbers: [1, 2, 3] };
    * const task = (input) => {
    *   return input.numbers.map(n => n * 2);
    * };
    *
    * const result = executor.exec(data, task);
+   * ```
    *
-   * // Example with validation
+   * @example With validation
+   * ```typescript
    * const result = executor.exec((data) => {
    *   if (typeof data !== 'string') {
    *     throw new Error('Data must be string');
@@ -3178,88 +3772,98 @@ var SyncExecutor = /*#__PURE__*/ function(Executor) {
         },
         {
             /**
+   * Execute core task logic with execHook support
+   *
+   * Core concept:
+   * Handles the execution phase with optional plugin intervention
+   *
+   * Execution logic:
+   * 1. Execute configured execHook (default: 'onExec')
+   * 2. If no execHook was executed, run the actual task
+   * 3. Otherwise, use the return value from execHook
+   *
+   * @template Result - Type of task return value
+   * @template Params - Type of task input parameters
+   * @param context - Execution context
+   * @param actualTask - Task function to execute
+   */ key: "runExec",
+            value: function runExec(context, actualTask) {
+                var _this_config;
+                var execHook = ((_this_config = this.config) === null || _this_config === void 0 ? void 0 : _this_config.execHook) || "onExec";
+                this.runHook(this.plugins, execHook, context, actualTask);
+                context.returnValue = !context.hooksRuntimes.times ? actualTask(context) : context.hooksRuntimes.returnValue;
+            }
+        },
+        {
+            /**
    * Core method to run synchronous task with plugin hooks
    * Implements the complete execution pipeline with all plugin hooks
    *
+   * Core concept:
+   * Complete execution pipeline with configurable hook lifecycle
+   *
    * Pipeline stages:
-   * 1. onBefore hooks - Pre-process input data
-   * 2. Task execution - Run the actual task
-   * 3. onSuccess hooks - Post-process results
+   * 1. beforeHooks - Pre-process input data (configurable, default: 'onBefore')
+   * 2. Task execution - Run the actual task with execHook support
+   * 3. afterHooks - Post-process results (configurable, default: 'onSuccess')
    * 4. onError hooks - Handle any errors
    *
    * Error handling strategy:
    * - Catches all errors
    * - Passes errors through plugin chain
    * - Wraps unhandled errors in ExecutorError
+   * - Supports plugin error handling
    *
-   * @template T - Type of task return value
-   * @template D - Type of task data
+   * @template Result - Type of task return value
+   * @template Params - Type of task input parameters
    * @param data - Data to pass to the task
    * @param actualTask - Actual task function to execute
    * @throws {ExecutorError} When task execution fails
    * @returns Task execution result
    *
-   * @example
+   * @example Internal implementation
    * ```typescript
-   * // Internal implementation example
-   * private run(data, task) {
+   * protected run(data, task) {
    *   try {
-   *     const preparedData = this.runHook(this.plugins, 'onBefore', data);
-   *     const result = task(preparedData);
-   *     return this.runHook(this.plugins, 'onSuccess', result);
+   *     // Execute beforeHooks (configurable)
+   *     this.runHooks(this.plugins, beforeHooks, context);
+   *
+   *     // Execute core logic with execHook support
+   *     this.runExec(context, actualTask);
+   *
+   *     // Execute afterHooks (configurable)
+   *     this.runHooks(this.plugins, afterHooks, context);
+   *
+   *     return context.returnValue;
    *   } catch (error) {
-   *     const handledError = this.runHook(
-   *       this.plugins,
-   *       'onError',
-   *       error,
-   *       data
-   *     );
-   *     // Error handling logic
+   *     // Handle errors with onError hooks
+   *     this.runHook(this.plugins, 'onError', context);
    *   }
    * }
    * ```
    */ key: "run",
             value: function run(data, actualTask) {
-                var _this = this;
-                var context = {
-                    parameters: data,
-                    returnValue: void 0,
-                    error: void 0,
-                    hooksRuntimes: {
-                        pluginName: "",
-                        hookName: "",
-                        returnValue: void 0,
-                        returnBreakChain: false,
-                        times: 0
-                    }
-                };
-                var runExec = function(ctx) {
-                    _this.runHooks(_this.plugins, "onExec", ctx, actualTask);
-                    ctx.returnValue = !ctx.hooksRuntimes.times ? actualTask(ctx) : ctx.hooksRuntimes.returnValue;
-                };
+                var _this_config, _this_config1;
+                var context = createContext(data);
+                var beforeHooks = ((_this_config = this.config) === null || _this_config === void 0 ? void 0 : _this_config.beforeHooks) || "onBefore";
+                var afterHooks = ((_this_config1 = this.config) === null || _this_config1 === void 0 ? void 0 : _this_config1.afterHooks) || "onSuccess";
                 try {
-                    this.runHooks(this.plugins, "onBefore", context);
-                    runExec(context);
-                    this.runHooks(this.plugins, "onSuccess", context);
+                    this.runHooks(this.plugins, beforeHooks, context);
+                    this.runExec(context, actualTask);
+                    this.runHooks(this.plugins, afterHooks, context);
                     return context.returnValue;
                 } catch (error) {
-                    context.error = error;
-                    this.runHooks(this.plugins, "onError", context);
+                    this.contextHandler.setError(context, error);
+                    this.runHook(this.plugins, "onError", context);
                     if (context.hooksRuntimes.returnValue) {
-                        context.error = context.hooksRuntimes.returnValue;
+                        this.contextHandler.setError(context, context.hooksRuntimes.returnValue);
                     }
                     if (_instanceof(context.error, ExecutorError)) {
                         throw context.error;
                     }
                     throw new ExecutorError("UNKNOWN_SYNC_ERROR", context.error);
                 } finally{
-                    context.hooksRuntimes = {
-                        pluginName: "",
-                        hookName: "",
-                        returnValue: void 0,
-                        returnBreakChain: false,
-                        times: 0
-                    };
+                    this.contextHandler.reset(context);
                 }
             }
         }