@logosdx/hooks 1.0.0-beta.2 → 1.0.0

package/dist/esm/index.mjs

@@ -209,21 +209,6 @@ function _non_iterable_rest() {
 function _non_iterable_spread() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _object_spread(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property(target, key, source[key]);
-        });
-    }
-    return target;
-}
 function _possible_constructor_return(self, call) {
     if (call && (_type_of(call) === "object" || typeof call === "function")) {
         return call;
@@ -398,17 +383,15 @@ import { assert, attempt, attemptSync, isFunction, isObject } from '@logosdx/uti
 /**
  * Error thrown when a hook calls `ctx.fail()`.
  *
- * This error is only created when using the default `handleFail` behavior.
+ * Only created when using the default `handleFail` behavior.
  * If a custom `handleFail` is provided, that error type is thrown instead.
  *
  * @example
- *     hooks.on('validate', async (ctx) => {
- *         if (!ctx.args[0].isValid) {
- *             ctx.fail('Validation failed');
- *         }
+ *     hooks.add('validate', (data, ctx) => {
+ *         if (!data.isValid) ctx.fail('Validation failed');
  *     });
  *
- *     const [, err] = await attempt(() => engine.emit('validate', data));
+ *     const [, err] = await attempt(() => engine.run('validate', data));
  *     if (isHookError(err)) {
  *         console.log(err.hookName);  // 'validate'
  *     }
@@ -429,32 +412,408 @@ import { assert, attempt, attemptSync, isFunction, isObject } from '@logosdx/uti
  * Type guard to check if an error is a HookError.
  *
  * @example
- *     const { error } = await engine.emit('validate', data);
- *     if (isHookError(error)) {
- *         console.log(`Hook "${error.hookName}" failed`);
+ *     const [, err] = await attempt(() => engine.run('validate', data));
+ *     if (isHookError(err)) {
+ *         console.log(`Hook "${err.hookName}" failed`);
  *     }
  */ export var isHookError = function(error) {
     var _error_constructor;
     return (error === null || error === void 0 ? void 0 : (_error_constructor = error.constructor) === null || _error_constructor === void 0 ? void 0 : _error_constructor.name) === HookError.name;
 };
-var _hooks = /*#__PURE__*/ new WeakMap(), _hookOpts = /*#__PURE__*/ new WeakMap(), _handleFail = /*#__PURE__*/ new WeakMap(), _registered = /*#__PURE__*/ new WeakMap(), /**
-     * Validate that a hook is registered (if registration is enabled).
-     */ _assertRegistered = /*#__PURE__*/ new WeakSet();
-export var HookEngine = /*#__PURE__*/ function() {
+var _data = /*#__PURE__*/ new WeakMap();
+/**
+ * Request-scoped state bag that flows across hook runs and engine instances.
+ *
+ * Use symbols for private plugin state and strings for shared cross-plugin contracts.
+ *
+ * @example
+ *     // Private plugin state (symbol key)
+ *     const CACHE_STATE = Symbol('cache');
+ *     ctx.scope.set(CACHE_STATE, { key, rule });
+ *
+ *     // Shared cross-plugin contract (string key)
+ *     ctx.scope.set('serializedKey', key);
+ */ export var HookScope = /*#__PURE__*/ function() {
+    "use strict";
+    function HookScope() {
+        _class_call_check(this, HookScope);
+        _class_private_field_init(this, _data, {
+            writable: true,
+            value: new Map()
+        });
+    }
+    _create_class(HookScope, [
+        {
+            /**
+     * Get a value from the scope.
+     *
+     * @example
+     *     const state = ctx.scope.get<CacheState>(CACHE_STATE);
+     */ key: "get",
+            value: function get(key) {
+                return _class_private_field_get(this, _data).get(key);
+            }
+        },
+        {
+            /**
+     * Set a value in the scope.
+     *
+     * @example
+     *     ctx.scope.set(CACHE_STATE, { key: 'abc', rule });
+     */ key: "set",
+            value: function set(key, value) {
+                _class_private_field_get(this, _data).set(key, value);
+            }
+        },
+        {
+            /**
+     * Check if a key exists in the scope.
+     */ key: "has",
+            value: function has(key) {
+                return _class_private_field_get(this, _data).has(key);
+            }
+        },
+        {
+            /**
+     * Delete a key from the scope.
+     */ key: "delete",
+            value: function _delete(key) {
+                return _class_private_field_get(this, _data).delete(key);
+            }
+        }
+    ]);
+    return HookScope;
+}();
+var EARLY_RETURN = Symbol('early-return');
+var _args = /*#__PURE__*/ new WeakMap(), _argsChanged = /*#__PURE__*/ new WeakMap(), _result = /*#__PURE__*/ new WeakMap(), _earlyReturn = /*#__PURE__*/ new WeakMap(), _handleFail = /*#__PURE__*/ new WeakMap(), _hookName = /*#__PURE__*/ new WeakMap(), _removeFn = /*#__PURE__*/ new WeakMap();
+/**
+ * Context object passed as the last argument to hook callbacks.
+ * Provides methods to modify args, short-circuit, fail, or self-remove.
+ *
+ * @example
+ *     // Replace args for downstream callbacks
+ *     hooks.add('beforeRequest', (url, opts, ctx) => {
+ *         ctx.args(url, { ...opts, cache: 'no-store' });
+ *     });
+ *
+ *     // Short-circuit: replace args AND stop the chain
+ *     hooks.add('beforeRequest', (url, opts, ctx) => {
+ *         return ctx.args(normalizedUrl, opts);
+ *     });
+ *
+ *     // Short-circuit with a result value
+ *     hooks.add('beforeRequest', (url, opts, ctx) => {
+ *         const cached = cache.get(url);
+ *         if (cached) return ctx.returns(cached);
+ *     });
+ */ export var HookContext = /*#__PURE__*/ function() {
+    "use strict";
+    function HookContext(handleFail, hookName, removeFn, scope) {
+        _class_call_check(this, HookContext);
+        _class_private_field_init(this, _args, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _argsChanged, {
+            writable: true,
+            value: false
+        });
+        _class_private_field_init(this, _result, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _earlyReturn, {
+            writable: true,
+            value: false
+        });
+        _class_private_field_init(this, _handleFail, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _hookName, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _removeFn, {
+            writable: true,
+            value: void 0
+        });
+        /**
+     * Request-scoped state bag shared across hook runs and engine instances.
+     *
+     * @example
+     *     // In beforeRequest hook
+     *     ctx.scope.set(CACHE_KEY, serializedKey);
+     *
+     *     // In afterRequest hook (same scope)
+     *     const key = ctx.scope.get<string>(CACHE_KEY);
+     */ _define_property(this, "scope", void 0);
+        _class_private_field_set(this, _handleFail, handleFail);
+        _class_private_field_set(this, _hookName, hookName);
+        _class_private_field_set(this, _removeFn, removeFn);
+        this.scope = scope;
+    }
+    _create_class(HookContext, [
+        {
+            /**
+     * Replace args for downstream callbacks.
+     * When used with `return`, also stops the chain.
+     *
+     * @example
+     *     // Just replace args, continue chain
+     *     ctx.args(newUrl, newOpts);
+     *
+     *     // Replace args AND stop the chain
+     *     return ctx.args(newUrl, newOpts);
+     */ key: "args",
+            value: function args() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                _class_private_field_set(this, _args, args);
+                _class_private_field_set(this, _argsChanged, true);
+                return EARLY_RETURN;
+            }
+        },
+        {
+            /**
+     * Set a result value and stop the chain.
+     * Always used with `return`.
+     *
+     * @example
+     *     return ctx.returns(cachedResponse);
+     */ key: "returns",
+            value: function returns(value) {
+                _class_private_field_set(this, _result, value);
+                _class_private_field_set(this, _earlyReturn, true);
+                return EARLY_RETURN;
+            }
+        },
+        {
+            /**
+     * Abort hook execution with an error.
+     * Uses the engine's `handleFail` to create the error.
+     *
+     * @example
+     *     ctx.fail('Validation failed');
+     */ key: "fail",
+            value: function fail() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                var _handler_prototype;
+                var handler = _class_private_field_get(this, _handleFail);
+                var isConstructor = typeof handler === 'function' && ((_handler_prototype = handler.prototype) === null || _handler_prototype === void 0 ? void 0 : _handler_prototype.constructor) === handler;
+                var _attemptSync = _sliced_to_array(attemptSync(function() {
+                    if (isConstructor) {
+                        throw _construct(handler, _to_consumable_array(args));
+                    }
+                    handler.apply(void 0, _to_consumable_array(args));
+                }), 2), error = _attemptSync[1];
+                if (error) {
+                    if (_instanceof(error, HookError)) {
+                        error.hookName = _class_private_field_get(this, _hookName);
+                    }
+                    throw error;
+                }
+                throw new HookError('ctx.fail() handler did not throw');
+            }
+        },
+        {
+            /**
+     * Remove this callback from future runs.
+     *
+     * @example
+     *     hooks.add('init', (config, ctx) => {
+     *         bootstrap(config);
+     *         ctx.removeHook();
+     *     });
+     */ key: "removeHook",
+            value: function removeHook() {
+                _class_private_field_get(this, _removeFn).call(this);
+            }
+        },
+        {
+            key: "_argsChanged",
+            get: /** @internal */ function get() {
+                return _class_private_field_get(this, _argsChanged);
+            }
+        },
+        {
+            key: "_newArgs",
+            get: /** @internal */ function get() {
+                return _class_private_field_get(this, _args);
+            }
+        },
+        {
+            key: "_result",
+            get: /** @internal */ function get() {
+                return _class_private_field_get(this, _result);
+            }
+        },
+        {
+            key: "_earlyReturn",
+            get: /** @internal */ function get() {
+                return _class_private_field_get(this, _earlyReturn);
+            }
+        }
+    ]);
+    return HookContext;
+}();
+var _handleFail1 = /*#__PURE__*/ new WeakMap(), _hookName1 = /*#__PURE__*/ new WeakMap(), _removeFn1 = /*#__PURE__*/ new WeakMap(), _setArgs = /*#__PURE__*/ new WeakMap();
+/**
+ * Context object passed as the last argument to pipe middleware callbacks.
+ * Simpler than HookContext — no `returns()` needed since you control
+ * flow by calling or not calling `next()`.
+ *
+ * @example
+ *     hooks.add('execute', async (next, opts, ctx) => {
+ *         // Modify opts for inner layers
+ *         ctx.args({ ...opts, headers: { ...opts.headers, Auth: token } });
+ *
+ *         // Call next to continue the chain, or don't to short-circuit
+ *         return next();
+ *     });
+ */ export var PipeContext = /*#__PURE__*/ function() {
+    "use strict";
+    function PipeContext(handleFail, hookName, removeFn, scope, setArgs) {
+        _class_call_check(this, PipeContext);
+        _class_private_field_init(this, _handleFail1, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _hookName1, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _removeFn1, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _setArgs, {
+            writable: true,
+            value: void 0
+        });
+        /**
+     * Request-scoped state bag shared across hook runs and engine instances.
+     */ _define_property(this, "scope", void 0);
+        _class_private_field_set(this, _handleFail1, handleFail);
+        _class_private_field_set(this, _hookName1, hookName);
+        _class_private_field_set(this, _removeFn1, removeFn);
+        this.scope = scope;
+        _class_private_field_set(this, _setArgs, setArgs);
+    }
+    _create_class(PipeContext, [
+        {
+            /**
+     * Replace args for `next()` and downstream middleware.
+     *
+     * @example
+     *     ctx.args({ ...opts, timeout: 5000 });
+     *     return next(); // next receives modified opts
+     */ key: "args",
+            value: function args() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                _class_private_field_get(this, _setArgs).call(this, args);
+            }
+        },
+        {
+            /**
+     * Abort execution with an error.
+     *
+     * @example
+     *     ctx.fail('Rate limit exceeded');
+     */ key: "fail",
+            value: function fail() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                var _handler_prototype;
+                var handler = _class_private_field_get(this, _handleFail1);
+                var isConstructor = typeof handler === 'function' && ((_handler_prototype = handler.prototype) === null || _handler_prototype === void 0 ? void 0 : _handler_prototype.constructor) === handler;
+                var _attemptSync = _sliced_to_array(attemptSync(function() {
+                    if (isConstructor) {
+                        throw _construct(handler, _to_consumable_array(args));
+                    }
+                    handler.apply(void 0, _to_consumable_array(args));
+                }), 2), error = _attemptSync[1];
+                if (error) {
+                    if (_instanceof(error, HookError)) {
+                        error.hookName = _class_private_field_get(this, _hookName1);
+                    }
+                    throw error;
+                }
+                throw new HookError('ctx.fail() handler did not throw');
+            }
+        },
+        {
+            /**
+     * Remove this middleware from future runs.
+     */ key: "removeHook",
+            value: function removeHook() {
+                _class_private_field_get(this, _removeFn1).call(this);
+            }
+        }
+    ]);
+    return PipeContext;
+}();
+var _hooks = /*#__PURE__*/ new WeakMap(), _handleFail2 = /*#__PURE__*/ new WeakMap(), _registered = /*#__PURE__*/ new WeakMap(), _callCounts = /*#__PURE__*/ new WeakMap(), /**
+     * Validate that a hook name is registered (when strict mode is active).
+     */ _assertRegistered = /*#__PURE__*/ new WeakSet(), /**
+     * Process a HookContext after a callback has run.
+     */ _processCtx = /*#__PURE__*/ new WeakSet(), /**
+     * Check times limit and increment counter. Returns true if exceeded.
+     */ _checkTimes = /*#__PURE__*/ new WeakSet(), /**
+     * Remove an entry from the hooks array.
+     */ _removeEntry = /*#__PURE__*/ new WeakSet(), /**
+     * Extract RunOptions from the args array if present.
+     */ _extractRunOptions = /*#__PURE__*/ new WeakSet();
+/**
+ * A lightweight, type-safe lifecycle hook system.
+ *
+ * HookEngine allows you to define lifecycle events and subscribe to them.
+ * Callbacks receive spread arguments with a context object as the last param.
+ *
+ * @example
+ *     interface FetchLifecycle {
+ *         beforeRequest(url: string, options: RequestInit): Promise<Response>;
+ *         afterRequest(response: Response, url: string): Promise<Response>;
+ *     }
+ *
+ *     const hooks = new HookEngine<FetchLifecycle>();
+ *
+ *     hooks.add('beforeRequest', (url, opts, ctx) => {
+ *         ctx.args(url, { ...opts, headers: { ...opts.headers, 'X-Token': token } });
+ *     });
+ *
+ *     hooks.add('beforeRequest', (url, opts, ctx) => {
+ *         const cached = cache.get(url);
+ *         if (cached) return ctx.returns(cached);
+ *     });
+ *
+ *     const pre = await hooks.run('beforeRequest', url, options);
+ *     if (pre.returned) return pre.result;
+ *     const response = await fetch(...pre.args);
+ *
+ * @typeParam Lifecycle - Interface defining the lifecycle hooks
+ * @typeParam FailArgs - Arguments type for ctx.fail() (default: [string])
+ */ export var HookEngine = /*#__PURE__*/ function() {
     "use strict";
     function HookEngine() {
         var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
         _class_call_check(this, HookEngine);
         _class_private_method_init(this, _assertRegistered);
+        _class_private_method_init(this, _processCtx);
+        _class_private_method_init(this, _checkTimes);
+        _class_private_method_init(this, _removeEntry);
+        _class_private_method_init(this, _extractRunOptions);
         _class_private_field_init(this, _hooks, {
             writable: true,
             value: new Map()
         });
-        _class_private_field_init(this, _hookOpts, {
-            writable: true,
-            value: new WeakMap()
-        });
-        _class_private_field_init(this, _handleFail, {
+        _class_private_field_init(this, _handleFail2, {
             writable: true,
             value: void 0
         });
@@ -462,8 +821,12 @@ export var HookEngine = /*#__PURE__*/ function() {
             writable: true,
             value: null
         });
+        _class_private_field_init(this, _callCounts, {
+            writable: true,
+            value: new WeakMap()
+        });
         var _options_handleFail;
-        _class_private_field_set(this, _handleFail, (_options_handleFail = options.handleFail) !== null && _options_handleFail !== void 0 ? _options_handleFail : function(message) {
+        _class_private_field_set(this, _handleFail2, (_options_handleFail = options.handleFail) !== null && _options_handleFail !== void 0 ? _options_handleFail : function(message) {
             throw new HookError(message);
         });
     }
@@ -478,10 +841,10 @@ export var HookEngine = /*#__PURE__*/ function() {
      *
      * @example
      *     const hooks = new HookEngine<FetchLifecycle>()
-     *         .register('preRequest', 'postRequest', 'rateLimit');
+     *         .register('beforeRequest', 'afterRequest');
      *
-     *     hooks.on('preRequest', cb);     // OK
-     *     hooks.on('preRequset', cb);     // Error: not registered (typo caught!)
+     *     hooks.add('beforeRequest', cb);     // OK
+     *     hooks.add('beforeRequset', cb);     // Error: not registered (typo caught!)
      */ key: "register",
             value: function register() {
                 for(var _len = arguments.length, names = new Array(_len), _key = 0; _key < _len; _key++){
@@ -520,142 +883,102 @@ export var HookEngine = /*#__PURE__*/ function() {
      * Subscribe to a lifecycle hook.
      *
      * @param name - Name of the lifecycle hook
-     * @param cbOrOpts - Callback function or options object
+     * @param callback - Callback function receiving spread args + ctx
+     * @param options - Options for this subscription
      * @returns Cleanup function to remove the subscription
      *
      * @example
      *     // Simple callback
-     *     const cleanup = hooks.on('preRequest', async (ctx) => {
-     *         console.log('Request:', ctx.args[0]);
+     *     const cleanup = hooks.add('beforeRequest', (url, opts, ctx) => {
+     *         console.log('Request:', url);
      *     });
      *
      *     // With options
-     *     hooks.on('analytics', {
-     *         callback: async (ctx) => { track(ctx.args); },
-     *         once: true,           // Remove after first run
-     *         ignoreOnFail: true    // Don't throw if callback fails
-     *     });
+     *     hooks.add('analytics', (event, ctx) => {
+     *         track(event);
+     *     }, { once: true, ignoreOnFail: true });
+     *
+     *     // With priority (lower runs first)
+     *     hooks.add('beforeRequest', cb, { priority: -10 });
      *
      *     // Remove subscription
      *     cleanup();
-     */ key: "on",
-            value: function on(name, cbOrOpts) {
-                var callback = typeof cbOrOpts === 'function' ? cbOrOpts : cbOrOpts === null || cbOrOpts === void 0 ? void 0 : cbOrOpts.callback;
-                var opts = typeof cbOrOpts === 'function' ? {} : cbOrOpts;
+     */ key: "add",
+            value: function add(name, callback) {
+                var _this = this;
+                var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
                 assert(typeof name === 'string', '"name" must be a string');
-                assert(isFunction(callback) || isObject(cbOrOpts), '"cbOrOpts" must be a callback or options');
-                assert(isFunction(callback), 'callback must be a function');
-                _class_private_method_get(this, _assertRegistered, assertRegistered).call(this, name, 'on');
+                assert(isFunction(callback), '"callback" must be a function');
+                _class_private_method_get(this, _assertRegistered, assertRegistered).call(this, name, 'add');
+                var _options_priority;
+                var priority = (_options_priority = options.priority) !== null && _options_priority !== void 0 ? _options_priority : 0;
+                var entry = {
+                    callback: callback,
+                    options: options,
+                    priority: priority
+                };
                 var _class_private_field_get_get;
-                var hooks = (_class_private_field_get_get = _class_private_field_get(this, _hooks).get(name)) !== null && _class_private_field_get_get !== void 0 ? _class_private_field_get_get : new Set();
-                hooks.add(callback);
+                var hooks = (_class_private_field_get_get = _class_private_field_get(this, _hooks).get(name)) !== null && _class_private_field_get_get !== void 0 ? _class_private_field_get_get : [];
+                var inserted = false;
+                for(var i = 0; i < hooks.length; i++){
+                    if (hooks[i].priority > priority) {
+                        hooks.splice(i, 0, entry);
+                        inserted = true;
+                        break;
+                    }
+                }
+                if (!inserted) {
+                    hooks.push(entry);
+                }
                 _class_private_field_get(this, _hooks).set(name, hooks);
-                _class_private_field_get(this, _hookOpts).set(callback, opts);
                 return function() {
-                    hooks.delete(callback);
+                    var arr = _class_private_field_get(_this, _hooks).get(name);
+                    if (arr) {
+                        var idx = arr.indexOf(entry);
+                        if (idx !== -1) {
+                            arr.splice(idx, 1);
+                        }
+                    }
                 };
             }
         },
         {
-            /**
-     * Subscribe to a lifecycle hook that fires only once.
-     * Sugar for `on(name, { callback, once: true })`.
-     *
-     * @param name - Name of the lifecycle hook
-     * @param callback - Callback function
-     * @returns Cleanup function to remove the subscription
-     *
-     * @example
-     *     // Log only the first request
-     *     hooks.once('preRequest', async (ctx) => {
-     *         console.log('First request:', ctx.args[0]);
-     *     });
-     */ key: "once",
-            value: function once(name, callback) {
-                return this.on(name, {
-                    callback: callback,
-                    once: true
-                });
-            }
-        },
-        {
-            key: "emit",
+            key: "run",
             value: /**
-     * Emit a lifecycle hook, running all subscribed callbacks.
+     * Run all callbacks for a hook asynchronously.
      *
-     * @param name - Name of the lifecycle hook to emit
-     * @param args - Arguments to pass to callbacks
-     * @returns EmitResult with final args, result, and earlyReturn flag
+     * @param name - Name of the lifecycle hook to run
+     * @param args - Arguments to pass to callbacks (spread + ctx)
+     * @returns RunResult with final args, result, and returned flag
      *
      * @example
-     *     const result = await hooks.emit('cacheCheck', url);
-     *
-     *     if (result.earlyReturn && result.result) {
-     *         return result.result;  // Use cached value
-     *     }
-     *
-     *     // Continue with modified args
-     *     const [modifiedUrl] = result.args;
-     */ function emit(name) {
+     *     const pre = await hooks.run('beforeRequest', url, options);
+     *     if (pre.returned) return pre.result;
+     *     const response = await fetch(...pre.args);
+     */ function run(name) {
                 for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
                     args[_key - 1] = arguments[_key];
                 }
                 return _async_to_generator(function() {
-                    var _this, earlyReturn, hooks, context, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _this1, _loop, _iterator, _step, _ret, err;
+                    var _this, _class_private_method_get_call, realArgs, runOptions, currentArgs, _runOptions_scope, scope, hooks, entries, result, returned, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _this1, _loop, _iterator, _step, _ret, err;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
                                 _this = this;
-                                _class_private_method_get(this, _assertRegistered, assertRegistered).call(this, name, 'emit');
-                                earlyReturn = false;
+                                _class_private_method_get(this, _assertRegistered, assertRegistered).call(this, name, 'run');
+                                _class_private_method_get_call = _class_private_method_get(this, _extractRunOptions, extractRunOptions).call(this, args), realArgs = _class_private_method_get_call.realArgs, runOptions = _class_private_method_get_call.runOptions;
+                                currentArgs = realArgs;
+                                scope = (_runOptions_scope = runOptions === null || runOptions === void 0 ? void 0 : runOptions.scope) !== null && _runOptions_scope !== void 0 ? _runOptions_scope : new HookScope();
                                 hooks = _class_private_field_get(this, _hooks).get(name);
-                                context = {
-                                    args: args,
-                                    removeHook: function removeHook() {},
-                                    returnEarly: function returnEarly() {
-                                        earlyReturn = true;
-                                    },
-                                    setArgs: function(next) {
-                                        assert(Array.isArray(next), "setArgs: args for '".concat(String(name), "' must be an array"));
-                                        context.args = next;
-                                    },
-                                    setResult: function(next) {
-                                        context.result = next;
-                                    },
-                                    fail: function() {
-                                        for(var _len = arguments.length, failArgs = new Array(_len), _key = 0; _key < _len; _key++){
-                                            failArgs[_key] = arguments[_key];
-                                        }
-                                        var _handler_prototype;
-                                        var handler = _class_private_field_get(_this, _handleFail);
-                                        // Check if handler is a constructor (class or function with prototype)
-                                        var isConstructor = typeof handler === 'function' && ((_handler_prototype = handler.prototype) === null || _handler_prototype === void 0 ? void 0 : _handler_prototype.constructor) === handler;
-                                        var _attemptSync = _sliced_to_array(attemptSync(function() {
-                                            if (isConstructor) {
-                                                throw _construct(handler, _to_consumable_array(failArgs));
-                                            }
-                                            handler.apply(void 0, _to_consumable_array(failArgs));
-                                        }), 2), error = _attemptSync[1];
-                                        if (error) {
-                                            if (_instanceof(error, HookError)) {
-                                                error.hookName = String(name);
-                                            }
-                                            throw error;
-                                        }
-                                        // If handler didn't throw, we need to throw something
-                                        throw new HookError('ctx.fail() handler did not throw');
-                                    }
-                                };
-                                if (!hooks || hooks.size === 0) {
-                                    return [
-                                        2,
-                                        {
-                                            args: context.args,
-                                            result: context.result,
-                                            earlyReturn: false
-                                        }
-                                    ];
+                                entries = hooks ? _to_consumable_array(hooks) : [];
+                                if (runOptions === null || runOptions === void 0 ? void 0 : runOptions.append) {
+                                    entries.push({
+                                        callback: runOptions.append,
+                                        options: {},
+                                        priority: Infinity
+                                    });
                                 }
+                                returned = false;
                                 _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                                 _state.label = 1;
                             case 1:
@@ -666,21 +989,57 @@ export var HookEngine = /*#__PURE__*/ function() {
                                     8
                                 ]);
                                 _loop = function() {
-                                    var fn, _class_private_field_get_get, opts, _ref, _$err;
+                                    var entry, callback, opts, timesExceeded, removeFn, ctx, _ref, _$err, signal;
                                     return _ts_generator(this, function(_state) {
                                         switch(_state.label){
                                             case 0:
-                                                fn = _step.value;
-                                                context.removeHook = function() {
-                                                    return hooks.delete(fn);
-                                                };
-                                                opts = (_class_private_field_get_get = _class_private_field_get(_this1, _hookOpts).get(fn)) !== null && _class_private_field_get_get !== void 0 ? _class_private_field_get_get : {
-                                                    callback: fn
+                                                entry = _step.value;
+                                                callback = entry.callback, opts = entry.options;
+                                                timesExceeded = _class_private_method_get(_this1, _checkTimes, checkTimes).call(_this1, callback, opts);
+                                                if (timesExceeded) {
+                                                    _class_private_method_get(_this1, _removeEntry, removeEntry).call(_this1, name, entry);
+                                                    return [
+                                                        2,
+                                                        "continue"
+                                                    ];
+                                                }
+                                                removeFn = function() {
+                                                    return _class_private_method_get(_this, _removeEntry, removeEntry).call(_this, name, entry);
                                                 };
+                                                ctx = new HookContext(_class_private_field_get(_this1, _handleFail2), String(name), removeFn, scope);
+                                                if (!opts.ignoreOnFail) return [
+                                                    3,
+                                                    2
+                                                ];
                                                 return [
                                                     4,
                                                     attempt(function() {
-                                                        return fn(_object_spread({}, context));
+                                                        return _async_to_generator(function() {
+                                                            var signal;
+                                                            return _ts_generator(this, function(_state) {
+                                                                switch(_state.label){
+                                                                    case 0:
+                                                                        return [
+                                                                            4,
+                                                                            callback.apply(void 0, _to_consumable_array(currentArgs).concat([
+                                                                                ctx
+                                                                            ]))
+                                                                        ];
+                                                                    case 1:
+                                                                        signal = _state.sent();
+                                                                        _class_private_method_get(this, _processCtx, processCtx).call(this, ctx, signal, function(a) {
+                                                                            currentArgs = a;
+                                                                        }, function(r) {
+                                                                            result = r;
+                                                                        }, function() {
+                                                                            returned = true;
+                                                                        });
+                                                                        return [
+                                                                            2
+                                                                        ];
+                                                                }
+                                                            });
+                                                        }).call(_this);
                                                     })
                                                 ];
                                             case 1:
@@ -688,11 +1047,33 @@ export var HookEngine = /*#__PURE__*/ function() {
                                                     _state.sent(),
                                                     2
                                                 ]), _$err = _ref[1];
-                                                if (opts.once) context.removeHook();
-                                                if (_$err && opts.ignoreOnFail !== true) {
-                                                    throw _$err;
-                                                }
-                                                if (earlyReturn) return [
+                                                if (!_$err && opts.once) removeFn();
+                                                if (returned) return [
+                                                    2,
+                                                    "break"
+                                                ];
+                                                return [
+                                                    2,
+                                                    "continue"
+                                                ];
+                                            case 2:
+                                                return [
+                                                    4,
+                                                    callback.apply(void 0, _to_consumable_array(currentArgs).concat([
+                                                        ctx
+                                                    ]))
+                                                ];
+                                            case 3:
+                                                signal = _state.sent();
+                                                _class_private_method_get(_this1, _processCtx, processCtx).call(_this1, ctx, signal, function(a) {
+                                                    currentArgs = a;
+                                                }, function(r) {
+                                                    result = r;
+                                                }, function() {
+                                                    returned = true;
+                                                });
+                                                if (opts.once) removeFn();
+                                                if (returned) return [
                                                     2,
                                                     "break"
                                                 ];
@@ -702,7 +1083,7 @@ export var HookEngine = /*#__PURE__*/ function() {
                                         }
                                     });
                                 };
-                                _iterator = hooks[Symbol.iterator]();
+                                _iterator = entries[Symbol.iterator]();
                                 _state.label = 2;
                             case 2:
                                 if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
@@ -757,9 +1138,10 @@ export var HookEngine = /*#__PURE__*/ function() {
                                 return [
                                     2,
                                     {
-                                        args: context.args,
-                                        result: context.result,
-                                        earlyReturn: earlyReturn
+                                        args: currentArgs,
+                                        result: result,
+                                        returned: returned,
+                                        scope: scope
                                     }
                                 ];
                         }
@@ -769,59 +1151,122 @@ export var HookEngine = /*#__PURE__*/ function() {
         },
         {
             /**
-     * Clear all registered hooks.
+     * Run all callbacks for a hook synchronously.
      *
-     * @example
-     *     hooks.on('preRequest', validator);
-     *     hooks.on('postRequest', logger);
+     * @param name - Name of the lifecycle hook to run
+     * @param args - Arguments to pass to callbacks (spread + ctx)
+     * @returns RunResult with final args, result, and returned flag
      *
-     *     // Reset for testing
-     *     hooks.clear();
-     */ key: "clear",
-            value: function clear() {
-                _class_private_field_get(this, _hooks).clear();
-                _class_private_field_set(this, _hookOpts, new WeakMap());
-                _class_private_field_set(this, _registered, null);
+     * @example
+     *     const pre = hooks.runSync('beforeValidation', data);
+     *     if (pre.returned) return pre.result;
+     */ key: "runSync",
+            value: function runSync(name) {
+                var _this = this;
+                for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+                    args[_key - 1] = arguments[_key];
+                }
+                _class_private_method_get(this, _assertRegistered, assertRegistered).call(this, name, 'runSync');
+                var _class_private_method_get_call = _class_private_method_get(this, _extractRunOptions, extractRunOptions).call(this, args), realArgs = _class_private_method_get_call.realArgs, runOptions = _class_private_method_get_call.runOptions;
+                var currentArgs = realArgs;
+                var _runOptions_scope;
+                var scope = (_runOptions_scope = runOptions === null || runOptions === void 0 ? void 0 : runOptions.scope) !== null && _runOptions_scope !== void 0 ? _runOptions_scope : new HookScope();
+                var hooks = _class_private_field_get(this, _hooks).get(name);
+                var entries = hooks ? _to_consumable_array(hooks) : [];
+                if (runOptions === null || runOptions === void 0 ? void 0 : runOptions.append) {
+                    entries.push({
+                        callback: runOptions.append,
+                        options: {},
+                        priority: Infinity
+                    });
+                }
+                var result;
+                var returned = false;
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    var _this1, _loop = function() {
+                        var entry = _step.value;
+                        var callback = entry.callback, opts = entry.options;
+                        var timesExceeded = _class_private_method_get(_this1, _checkTimes, checkTimes).call(_this1, callback, opts);
+                        if (timesExceeded) {
+                            _class_private_method_get(_this1, _removeEntry, removeEntry).call(_this1, name, entry);
+                            return "continue";
+                        }
+                        var removeFn = function() {
+                            return _class_private_method_get(_this, _removeEntry, removeEntry).call(_this, name, entry);
+                        };
+                        var ctx = new HookContext(_class_private_field_get(_this1, _handleFail2), String(name), removeFn, scope);
+                        if (opts.ignoreOnFail) {
+                            var _attemptSync = _sliced_to_array(attemptSync(function() {
+                                var signal = callback.apply(void 0, _to_consumable_array(currentArgs).concat([
+                                    ctx
+                                ]));
+                                _class_private_method_get(_this, _processCtx, processCtx).call(_this, ctx, signal, function(a) {
+                                    currentArgs = a;
+                                }, function(r) {
+                                    result = r;
+                                }, function() {
+                                    returned = true;
+                                });
+                            }), 2), _$err = _attemptSync[1];
+                            if (!_$err && opts.once) removeFn();
+                            if (returned) return "break";
+                            return "continue";
+                        }
+                        var signal = callback.apply(void 0, _to_consumable_array(currentArgs).concat([
+                            ctx
+                        ]));
+                        _class_private_method_get(_this1, _processCtx, processCtx).call(_this1, ctx, signal, function(a) {
+                            currentArgs = a;
+                        }, function(r) {
+                            result = r;
+                        }, function() {
+                            returned = true;
+                        });
+                        if (opts.once) removeFn();
+                        if (returned) return "break";
+                    };
+                    for(var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _ret = (_this1 = this, _loop());
+                        if (_ret === "break") break;
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return {
+                    args: currentArgs,
+                    result: result,
+                    returned: returned,
+                    scope: scope
+                };
             }
         },
         {
             /**
-     * Wrap a function with pre/post lifecycle hooks.
+     * Wrap an async function with pre/post lifecycle hooks.
      *
-     * - Pre hook: emitted with function args, can modify args or returnEarly with result
-     * - Post hook: emitted with [result, ...args], can modify result
+     * - Pre hook: called with function args, can modify args or return early
+     * - Post hook: called with `(result, ...originalArgs)`, can transform result
      *
      * @param fn - The async function to wrap
      * @param hooks - Object with optional pre and post hook names
      * @returns Wrapped function with same signature
      *
      * @example
-     *     interface Lifecycle {
-     *         preRequest(url: string, opts: RequestInit): Promise<Response>;
-     *         postRequest(result: Response, url: string, opts: RequestInit): Promise<Response>;
-     *     }
-     *
-     *     const hooks = new HookEngine<Lifecycle>();
-     *
-     *     // Add cache check in pre hook
-     *     hooks.on('preRequest', async (ctx) => {
-     *         const cached = cache.get(ctx.args[0]);
-     *         if (cached) {
-     *             ctx.setResult(cached);
-     *             ctx.returnEarly();
-     *         }
-     *     });
-     *
-     *     // Log result in post hook
-     *     hooks.on('postRequest', async (ctx) => {
-     *         const [result, url] = ctx.args;
-     *         console.log(`Fetched ${url}:`, result.status);
-     *     });
-     *
-     *     // Wrap the fetch function
      *     const wrappedFetch = hooks.wrap(
      *         async (url: string, opts: RequestInit) => fetch(url, opts),
-     *         { pre: 'preRequest', post: 'postRequest' }
+     *         { pre: 'beforeRequest', post: 'afterRequest' }
      *     );
      */ key: "wrap",
             value: function wrap(fn, hooks) {
@@ -834,7 +1279,7 @@ export var HookEngine = /*#__PURE__*/ function() {
                         args[_key] = arguments[_key];
                     }
                     return _async_to_generator(function() {
-                        var currentArgs, result, preResult, postResult;
+                        var currentArgs, preResult, result, postResult;
                         return _ts_generator(this, function(_state) {
                             switch(_state.label){
                                 case 0:
@@ -845,14 +1290,14 @@ export var HookEngine = /*#__PURE__*/ function() {
                                     ];
                                     return [
                                         4,
-                                        this.emit.apply(this, [
+                                        this.run.apply(this, [
                                             hooks.pre
                                         ].concat(_to_consumable_array(currentArgs)))
                                     ];
                                 case 1:
                                     preResult = _state.sent();
                                     currentArgs = preResult.args;
-                                    if (preResult.earlyReturn && preResult.result !== undefined) {
+                                    if (preResult.returned && preResult.result !== undefined) {
                                         return [
                                             2,
                                             preResult.result
@@ -865,7 +1310,6 @@ export var HookEngine = /*#__PURE__*/ function() {
                                         fn.apply(void 0, _to_consumable_array(currentArgs))
                                     ];
                                 case 3:
-                                    // Execute function
                                     result = _state.sent();
                                     if (!hooks.post) return [
                                         3,
@@ -873,7 +1317,7 @@ export var HookEngine = /*#__PURE__*/ function() {
                                     ];
                                     return [
                                         4,
-                                        this.emit.apply(this, [
+                                        this.run.apply(this, [
                                             hooks.post
                                         ].concat(_to_consumable_array([
                                             result
@@ -881,7 +1325,7 @@ export var HookEngine = /*#__PURE__*/ function() {
                                     ];
                                 case 4:
                                     postResult = _state.sent();
-                                    if (postResult.result !== undefined) {
+                                    if (postResult.returned) {
                                         return [
                                             2,
                                             postResult.result
@@ -898,6 +1342,294 @@ export var HookEngine = /*#__PURE__*/ function() {
                     }).call(_this);
                 };
             }
+        },
+        {
+            /**
+     * Wrap a synchronous function with pre/post lifecycle hooks.
+     *
+     * @param fn - The sync function to wrap
+     * @param hooks - Object with optional pre and post hook names
+     * @returns Wrapped function with same signature
+     *
+     * @example
+     *     const wrappedValidate = hooks.wrapSync(
+     *         (data: UserData) => validate(data),
+     *         { pre: 'beforeValidate' }
+     *     );
+     */ key: "wrapSync",
+            value: function wrapSync(fn, hooks) {
+                var _this = this;
+                assert(hooks.pre || hooks.post, 'wrapSync() requires at least one of "pre" or "post" hooks');
+                if (hooks.pre) _class_private_method_get(this, _assertRegistered, assertRegistered).call(this, hooks.pre, 'wrapSync');
+                if (hooks.post) _class_private_method_get(this, _assertRegistered, assertRegistered).call(this, hooks.post, 'wrapSync');
+                return function() {
+                    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                        args[_key] = arguments[_key];
+                    }
+                    var currentArgs = args;
+                    if (hooks.pre) {
+                        var preResult = _this.runSync.apply(_this, [
+                            hooks.pre
+                        ].concat(_to_consumable_array(currentArgs)));
+                        currentArgs = preResult.args;
+                        if (preResult.returned && preResult.result !== undefined) {
+                            return preResult.result;
+                        }
+                    }
+                    var result = fn.apply(void 0, _to_consumable_array(currentArgs));
+                    if (hooks.post) {
+                        var postResult = _this.runSync.apply(_this, [
+                            hooks.post
+                        ].concat(_to_consumable_array([
+                            result
+                        ].concat(_to_consumable_array(currentArgs)))));
+                        if (postResult.returned) {
+                            return postResult.result;
+                        }
+                    }
+                    return result;
+                };
+            }
+        },
+        {
+            key: "pipe",
+            value: /**
+     * Execute middleware hooks as an onion (nested) composition.
+     *
+     * Unlike `run()` which executes hooks linearly, `pipe()` composes hooks
+     * as nested middleware. Each hook receives a `next` function that calls
+     * the next layer. The innermost layer is `coreFn`. Control flow is
+     * managed by calling or not calling `next()` — no `ctx.returns()` needed.
+     *
+     * Hooks execute in priority order (lower first = outermost layer).
+     *
+     * @param name - Name of the lifecycle hook
+     * @param coreFn - The innermost function to wrap
+     * @param args - Arguments passed to each middleware
+     * @returns The result from the middleware chain
+     *
+     * @example
+     *     // Retry plugin wraps the fetch call
+     *     hooks.add('execute', async (next, opts, ctx) => {
+     *         for (let i = 0; i < 3; i++) {
+     *             const [result, err] = await attempt(next);
+     *             if (!err) return result;
+     *             await wait(1000 * i);
+     *         }
+     *         throw lastError;
+     *     }, { priority: -20 });
+     *
+     *     // Dedupe plugin wraps retry
+     *     hooks.add('execute', async (next, opts, ctx) => {
+     *         const inflight = getInflight(key);
+     *         if (inflight) return inflight;
+     *         const result = await next();
+     *         share(result);
+     *         return result;
+     *     }, { priority: -30 });
+     *
+     *     // Execute: dedupe( retry( makeCall() ) )
+     *     const response = await hooks.pipe(
+     *         'execute',
+     *         () => makeCall(opts),
+     *         opts
+     *     );
+     */ function pipe(name, coreFn) {
+                for(var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+                    args[_key - 2] = arguments[_key];
+                }
+                return _async_to_generator(function() {
+                    var _this, _class_private_method_get_call, realArgs, runOptions, _runOptions_scope, scope, hooks, entries, currentArgs, buildChain;
+                    return _ts_generator(this, function(_state) {
+                        _this = this;
+                        _class_private_method_get(this, _assertRegistered, assertRegistered).call(this, name, 'pipe');
+                        _class_private_method_get_call = _class_private_method_get(this, _extractRunOptions, extractRunOptions).call(this, args), realArgs = _class_private_method_get_call.realArgs, runOptions = _class_private_method_get_call.runOptions;
+                        scope = (_runOptions_scope = runOptions === null || runOptions === void 0 ? void 0 : runOptions.scope) !== null && _runOptions_scope !== void 0 ? _runOptions_scope : new HookScope();
+                        hooks = _class_private_field_get(this, _hooks).get(name);
+                        entries = hooks ? _to_consumable_array(hooks) : [];
+                        if (runOptions === null || runOptions === void 0 ? void 0 : runOptions.append) {
+                            entries.push({
+                                callback: runOptions.append,
+                                options: {},
+                                priority: Infinity
+                            });
+                        }
+                        currentArgs = realArgs;
+                        buildChain = function(index) {
+                            if (index >= entries.length) return coreFn;
+                            return function() {
+                                return _async_to_generator(function() {
+                                    var _this, entry, callback, opts, timesExceeded, removeFn, ctx, next, cb, _ref, result, err, result1;
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                _this = this;
+                                                entry = entries[index];
+                                                callback = entry.callback, opts = entry.options;
+                                                timesExceeded = _class_private_method_get(this, _checkTimes, checkTimes).call(this, callback, opts);
+                                                if (timesExceeded) {
+                                                    _class_private_method_get(this, _removeEntry, removeEntry).call(this, name, entry);
+                                                    return [
+                                                        2,
+                                                        buildChain(index + 1)()
+                                                    ];
+                                                }
+                                                removeFn = function() {
+                                                    return _class_private_method_get(_this, _removeEntry, removeEntry).call(_this, name, entry);
+                                                };
+                                                ctx = new PipeContext(_class_private_field_get(this, _handleFail2), String(name), removeFn, scope, function(newArgs) {
+                                                    currentArgs = newArgs;
+                                                });
+                                                next = buildChain(index + 1);
+                                                cb = callback;
+                                                if (!opts.ignoreOnFail) return [
+                                                    3,
+                                                    2
+                                                ];
+                                                return [
+                                                    4,
+                                                    attempt(function() {
+                                                        return _async_to_generator(function() {
+                                                            return _ts_generator(this, function(_state) {
+                                                                return [
+                                                                    2,
+                                                                    cb.apply(void 0, [
+                                                                        next
+                                                                    ].concat(_to_consumable_array(currentArgs), [
+                                                                        ctx
+                                                                    ]))
+                                                                ];
+                                                            });
+                                                        })();
+                                                    })
+                                                ];
+                                            case 1:
+                                                _ref = _sliced_to_array.apply(void 0, [
+                                                    _state.sent(),
+                                                    2
+                                                ]), result = _ref[0], err = _ref[1];
+                                                if (opts.once) removeFn();
+                                                if (err) return [
+                                                    2,
+                                                    next()
+                                                ];
+                                                return [
+                                                    2,
+                                                    result
+                                                ];
+                                            case 2:
+                                                return [
+                                                    4,
+                                                    cb.apply(void 0, [
+                                                        next
+                                                    ].concat(_to_consumable_array(currentArgs), [
+                                                        ctx
+                                                    ]))
+                                                ];
+                                            case 3:
+                                                result1 = _state.sent();
+                                                if (opts.once) removeFn();
+                                                return [
+                                                    2,
+                                                    result1
+                                                ];
+                                        }
+                                    });
+                                }).call(_this);
+                            };
+                        };
+                        return [
+                            2,
+                            buildChain(0)()
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            /**
+     * Synchronous version of `pipe()`.
+     *
+     * @param name - Name of the lifecycle hook
+     * @param coreFn - The innermost function to wrap
+     * @param args - Arguments passed to each middleware
+     * @returns The result from the middleware chain
+     */ key: "pipeSync",
+            value: function pipeSync(name, coreFn) {
+                var _this = this;
+                for(var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+                    args[_key - 2] = arguments[_key];
+                }
+                _class_private_method_get(this, _assertRegistered, assertRegistered).call(this, name, 'pipeSync');
+                var _class_private_method_get_call = _class_private_method_get(this, _extractRunOptions, extractRunOptions).call(this, args), realArgs = _class_private_method_get_call.realArgs, runOptions = _class_private_method_get_call.runOptions;
+                var _runOptions_scope;
+                var scope = (_runOptions_scope = runOptions === null || runOptions === void 0 ? void 0 : runOptions.scope) !== null && _runOptions_scope !== void 0 ? _runOptions_scope : new HookScope();
+                var hooks = _class_private_field_get(this, _hooks).get(name);
+                var entries = hooks ? _to_consumable_array(hooks) : [];
+                if (runOptions === null || runOptions === void 0 ? void 0 : runOptions.append) {
+                    entries.push({
+                        callback: runOptions.append,
+                        options: {},
+                        priority: Infinity
+                    });
+                }
+                var currentArgs = realArgs;
+                var buildChain = function(index) {
+                    if (index >= entries.length) return coreFn;
+                    return function() {
+                        var entry = entries[index];
+                        var callback = entry.callback, opts = entry.options;
+                        var timesExceeded = _class_private_method_get(_this, _checkTimes, checkTimes).call(_this, callback, opts);
+                        if (timesExceeded) {
+                            _class_private_method_get(_this, _removeEntry, removeEntry).call(_this, name, entry);
+                            return buildChain(index + 1)();
+                        }
+                        var removeFn = function() {
+                            return _class_private_method_get(_this, _removeEntry, removeEntry).call(_this, name, entry);
+                        };
+                        var ctx = new PipeContext(_class_private_field_get(_this, _handleFail2), String(name), removeFn, scope, function(newArgs) {
+                            currentArgs = newArgs;
+                        });
+                        var next = buildChain(index + 1);
+                        var cb = callback;
+                        if (opts.ignoreOnFail) {
+                            var _attemptSync = _sliced_to_array(attemptSync(function() {
+                                return cb.apply(void 0, [
+                                    next
+                                ].concat(_to_consumable_array(currentArgs), [
+                                    ctx
+                                ]));
+                            }), 2), result = _attemptSync[0], err = _attemptSync[1];
+                            if (opts.once) removeFn();
+                            if (err) return next();
+                            return result;
+                        }
+                        var result1 = cb.apply(void 0, [
+                            next
+                        ].concat(_to_consumable_array(currentArgs), [
+                            ctx
+                        ]));
+                        if (opts.once) removeFn();
+                        return result1;
+                    };
+                };
+                return buildChain(0)();
+            }
+        },
+        {
+            /**
+     * Clear all hooks and reset registration state.
+     *
+     * @example
+     *     hooks.add('beforeRequest', validator);
+     *     hooks.clear();
+     *     // All hooks removed, back to permissive mode
+     */ key: "clear",
+            value: function clear() {
+                _class_private_field_get(this, _hooks).clear();
+                _class_private_field_set(this, _registered, null);
+                _class_private_field_set(this, _callCounts, new WeakMap());
+            }
         }
     ]);
     return HookEngine;
@@ -908,3 +1640,46 @@ function assertRegistered(name, method) {
         throw new Error('Hook "'.concat(String(name), '" is not registered. ') + 'Call register("'.concat(String(name), '") before using ').concat(method, "(). ") + "Registered hooks: ".concat(registered || '(none)'));
     }
 }
+function processCtx(ctx, signal, setArgs, setResult, setReturned) {
+    if (ctx._earlyReturn) {
+        setResult(ctx._result);
+        setReturned();
+        return;
+    }
+    if (ctx._argsChanged) {
+        setArgs(ctx._newArgs);
+        if (signal === EARLY_RETURN) {
+            setReturned();
+        }
+    }
+}
+function checkTimes(callback, opts) {
+    if (opts.times === undefined) return false;
+    var _class_private_field_get_get;
+    var count = (_class_private_field_get_get = _class_private_field_get(this, _callCounts).get(callback)) !== null && _class_private_field_get_get !== void 0 ? _class_private_field_get_get : 0;
+    if (count >= opts.times) return true;
+    _class_private_field_get(this, _callCounts).set(callback, count + 1);
+    return false;
+}
+function removeEntry(name, entry) {
+    var arr = _class_private_field_get(this, _hooks).get(name);
+    if (arr) {
+        var idx = arr.indexOf(entry);
+        if (idx !== -1) {
+            arr.splice(idx, 1);
+        }
+    }
+}
+function extractRunOptions(args) {
+    var last = args[args.length - 1];
+    if (isObject(last) && ('append' in last && isFunction(last.append) || 'scope' in last && _instanceof(last.scope, HookScope))) {
+        return {
+            realArgs: args.slice(0, -1),
+            runOptions: last
+        };
+    }
+    return {
+        realArgs: args,
+        runOptions: undefined
+    };
+}