moost 0.5.33 → 0.6.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { Mate, getConstructor, getConstructor as getConstructor$1, isConstructor, isConstructor as isConstructor$1 } from "@prostojs/mate";
-import { ContextInjector, EventLogger, createAsyncEventContext, getContextInjector, getContextInjector as getContextInjector$1, replaceContextInjector, useAsyncEventContext, useAsyncEventContext as useAsyncEventContext$1, useEventId, useEventLogger, useEventLogger as useEventLogger$1, useRouteParams } from "@wooksjs/event-core";
+import { ContextInjector, cached, createEventContext, createEventContext as createEventContext$1, current, current as current$1, defineWook, eventTypeKey, getContextInjector, getContextInjector as getContextInjector$1, key, key as key$1, replaceContextInjector, resetContextInjector, run, useLogger, useLogger as useLogger$1, useRouteParams } from "@wooksjs/event-core";
 import { Infact, createProvideRegistry, createProvideRegistry as createProvideRegistry$1, createReplaceRegistry, createReplaceRegistry as createReplaceRegistry$1 } from "@prostojs/infact";
+import { Mate, getConstructor, getConstructor as getConstructor$1, isConstructor, isConstructor as isConstructor$1 } from "@prostojs/mate";
 import { ProstoLogger, ProstoLogger as ProstoLogger$1, coloredConsole, createConsoleTransort } from "@prostojs/logger";
 import { Hookable } from "hookable";
 import { clearGlobalWooks, getGlobalWooks } from "wooks";
@@ -17,20 +17,48 @@ function getDefaultLogger(topic) {
 	});
 	return topic && defaultLogger instanceof ProstoLogger$1 ? defaultLogger.createTopic(topic) : defaultLogger;
 }
-function createLogger(opts) {
+/** Creates a new `ProstoLogger` instance with sensible defaults (level 4, colored console). */ function createLogger(opts) {
 	return new ProstoLogger$1({
 		...opts,
 		level: opts?.level ?? 4,
 		transports: opts?.transports ?? [loggerConsoleTransport]
 	});
 }
-const loggerConsoleTransport = createConsoleTransort({ format: coloredConsole });
+/** Default colored console transport used by Moost loggers. */ const loggerConsoleTransport = createConsoleTransort({ format: coloredConsole });
+
+//#endregion
+//#region packages/moost/src/shared-utils.ts
+/**
+* Checks whether a value is a PromiseLike (thenable).
+* Single source of truth — import from here instead of duplicating.
+*/ function isThenable(value) {
+	return value !== null && value !== void 0 && typeof value.then === "function";
+}
+/**
+* Merges multiple arrays of items with a `priority` field, returning a
+* single sorted-by-priority array.  Accepts `undefined` entries for convenience.
+*/ function mergeSorted(...lists) {
+	let total = 0;
+	for (const l of lists) if (l) total += l.length;
+	if (total === 0) return [];
+	const merged = [];
+	for (const l of lists) if (l) for (const item of l) merged.push(item);
+	return merged.toSorted((a, b) => a.priority - b.priority);
+}
 
 //#endregion
 //#region packages/moost/src/pipes/run-pipes.ts
-async function runPipes(pipes, initialValue, metas, level) {
+function runPipes(pipes, initialValue, metas, level) {
 	let v = initialValue;
-	for (const pipe of pipes) v = await pipe.handler(v, metas, level);
+	for (let i = 0; i < pipes.length; i++) {
+		const result = pipes[i].handler(v, metas, level);
+		if (isThenable(result)) return (async () => {
+			v = await result;
+			for (let j = i + 1; j < pipes.length; j++) v = await pipes[j].handler(v, metas, level);
+			return v;
+		})();
+		v = result;
+	}
 	return v;
 }
 
@@ -47,7 +75,7 @@ const moostMate = new Mate(METADATA_WORKSPACE, {
 		return !!targetMeta?.inherit;
 	}
 });
-function getMoostMate() {
+/** Returns the shared `Mate` instance operating in the `'moost'` metadata workspace. */ function getMoostMate() {
 	return moostMate;
 }
 
@@ -60,13 +88,13 @@ let loggingOptions = {
 	warn: true,
 	error: true
 };
-function setInfactLoggingOptions(options) {
+/** Configures which Infact DI events are logged (instance creation, warnings, errors). */ function setInfactLoggingOptions(options) {
 	loggingOptions = {
 		...loggingOptions,
 		...options
 	};
 }
-function getMoostInfact() {
+/** Returns the shared Infact DI container used by Moost for dependency injection. */ function getMoostInfact() {
 	return sharedMoostInfact;
 }
 const scopeVarsMap = /* @__PURE__ */ new Map();
@@ -99,7 +127,7 @@ const scopeVarsMap = /* @__PURE__ */ new Map();
 				constructorParams: meta?.params || [],
 				provide: meta?.provide,
 				properties: meta?.properties || [],
-				scopeId: meta?.injectable === "FOR_EVENT" ? useEventId().getId() : void 0
+				scopeId: meta?.injectable === "FOR_EVENT" ? useScopeId() : void 0
 			};
 		},
 		resolveParam({ paramMeta, customData, classConstructor, index, scopeId, instantiate }) {
@@ -114,15 +142,15 @@ const scopeVarsMap = /* @__PURE__ */ new Map();
 				instantiate
 			}, "PARAM");
 		},
-		describeProp(classConstructor, key) {
-			const meta = getMoostMate().read(classConstructor, key);
+		describeProp(classConstructor, key$2) {
+			const meta = getMoostMate().read(classConstructor, key$2);
 			return meta;
 		},
-		resolveProp({ instance, key, initialValue, propMeta, scopeId, classMeta, customData, classConstructor, instantiate }) {
+		resolveProp({ instance, key: key$2, initialValue, propMeta, scopeId, classMeta, customData, classConstructor, instantiate }) {
 			if (propMeta && customData?.pipes) return runPipes(customData.pipes, initialValue, {
 				instance,
 				type: classConstructor,
-				key,
+				key: key$2,
 				scopeId,
 				propMeta,
 				targetMeta: propMeta,
@@ -150,7 +178,8 @@ const scopeVarsMap = /* @__PURE__ */ new Map();
 			}
 			let logger;
 			try {
-				logger = event === "error" ? getDefaultLogger(INFACT_BANNER) : useEventLogger$1(INFACT_BANNER);
+				const ctxLogger = event === "error" ? getDefaultLogger(INFACT_BANNER) : useLogger$1();
+				logger = typeof ctxLogger.topic === "function" ? ctxLogger.topic(INFACT_BANNER) : ctxLogger;
 			} catch (error) {
 				logger = getDefaultLogger(INFACT_BANNER);
 			}
@@ -192,19 +221,26 @@ const scopeVarsMap = /* @__PURE__ */ new Map();
 
 //#endregion
 //#region packages/moost/src/composables/controller.composable.ts
-function setControllerContext(controller, method, route) {
-	const { store } = useAsyncEventContext$1();
-	const { set } = store("controller");
-	set("instance", controller);
-	set("method", method);
-	set("route", route);
-}
-function useControllerContext() {
-	const { store } = useAsyncEventContext$1();
-	const { get } = store("controller");
-	const getController = () => get("instance");
-	const getMethod = () => get("method");
-	const getRoute = () => get("route");
+const controllerInstanceKey = key$1("controller.instance");
+const controllerMethodKey = key$1("controller.method");
+const controllerRouteKey = key$1("controller.route");
+/**
+* Sets the controller context for the current event scope.
+* Called internally by adapters when dispatching events to handlers.
+*/ function setControllerContext(controller, method, route, ctx) {
+	const _ctx = ctx || current$1();
+	_ctx.set(controllerInstanceKey, controller);
+	_ctx.set(controllerMethodKey, method);
+	_ctx.set(controllerRouteKey, route);
+}
+/**
+* Provides access to the current controller context within an event handler.
+* Returns utilities for accessing the controller instance, method metadata, and DI.
+*/ function useControllerContext(ctx) {
+	const _ctx = ctx || current$1();
+	const getController = () => _ctx.get(controllerInstanceKey);
+	const getMethod = () => _ctx.get(controllerMethodKey);
+	const getRoute = () => _ctx.get(controllerRouteKey);
 	const getControllerMeta = () => getMoostMate().read(getController());
 	const getMethodMeta = (name) => getMoostMate().read(getController(), name || getMethod());
 	function instantiate(c) {
@@ -224,105 +260,204 @@ function useControllerContext() {
 	};
 }
 
+//#endregion
+//#region packages/moost/src/composables/interceptor.composable.ts
+var _g, _g1;
+const g = globalThis;
+const overtakeKey = (_g = g).__moost_overtakeKey ?? (_g.__moost_overtakeKey = key$1("interceptor.overtake"));
+const interceptResultKey = (_g1 = g).__moost_interceptResultKey ?? (_g1.__moost_interceptResultKey = key$1("interceptor.result"));
+/** Stores the overtake (reply) function in the current event context. */ function setOvertake(fn, ctx) {
+	(ctx || current$1()).set(overtakeKey, fn);
+}
+/** Retrieves the overtake (reply) function from the current event context. */ function useOvertake(ctx) {
+	return (ctx || current$1()).get(overtakeKey);
+}
+/** Stores the interceptor result value in the current event context. */ function setInterceptResult(value, ctx) {
+	(ctx || current$1()).set(interceptResultKey, value);
+}
+/** Retrieves the interceptor result value from the current event context. */ function useInterceptResult(ctx) {
+	return (ctx || current$1()).get(interceptResultKey);
+}
+
 //#endregion
 //#region packages/moost/src/adapter-utils.ts
-const infact = getMoostInfact();
-function registerEventScope(scopeId) {
+let _scopeChar = "a";
+let _scopeNum = 0;
+function nextScopeId() {
+	if (_scopeNum >= Number.MAX_SAFE_INTEGER) {
+		_scopeNum = 0;
+		_scopeChar = _scopeChar === "z" ? "a" : String.fromCodePoint((_scopeChar.codePointAt(0) ?? 97) + 1);
+	}
+	return `__moost_${_scopeChar}_${++_scopeNum}`;
+}
+/** Composable returning the moost scope ID for the current event. Generates on first call, caches for subsequent calls. */ const useScopeId = defineWook(() => nextScopeId());
+/** Registers a DI scope for the given ID and returns an unscope function. */ function registerEventScope(scopeId) {
+	const infact = getMoostInfact();
 	infact.registerScope(scopeId);
 	return () => {
 		infact.unregisterScope(scopeId);
 	};
 }
-function defineMoostEventHandler(options) {
+/**
+* Creates the complete event handler lifecycle processor used by adapters.
+* Handles scope registration, controller resolution, interceptors, argument resolution,
+* handler invocation, and cleanup — optimised for sync-first execution.
+*/ function defineMoostEventHandler(options) {
 	const ci = getContextInjector$1();
-	return async () => {
-		const scopeId = useEventId().getId();
-		const logger = useEventLogger$1(options.loggerTitle);
+	const handlerSpanName = `Handler:${options.targetPath}`;
+	const handlerAttrs = {
+		"moost.handler": options.controllerMethod || "",
+		"moost.controller": options.controllerName || ""
+	};
+	return () => {
+		const ctx = current$1();
+		const scopeId = useScopeId(ctx);
+		const ctxLogger = useLogger$1(ctx);
+		const logger = typeof ctxLogger.topic === "function" ? ctxLogger.topic(options.loggerTitle) : ctxLogger;
 		const unscope = registerEventScope(scopeId);
 		let response;
-		const hookOptions = {
-			scopeId,
-			logger,
-			unscope,
-			method: options.controllerMethod,
-			getResponse: () => response,
-			reply: (r) => response = r
-		};
-		if (options.hooks?.init) await options.hooks.init(hookOptions);
-		const instance = await options.getControllerInstance();
-		if (instance) {
-			setControllerContext(instance, options.controllerMethod || "", options.targetPath);
-			ci.hook(options.handlerType, "Controller:registered");
+		let hookOptions;
+		function getHookOptions() {
+			return hookOptions ?? (hookOptions = {
+				scopeId,
+				logger,
+				unscope,
+				method: options.controllerMethod,
+				getResponse: () => response,
+				reply: (r) => response = r
+			});
 		}
-		const interceptorHandler = await options.getIterceptorHandler();
-		if (interceptorHandler?.count) try {
-			response = await ci.with("Interceptors:init", () => interceptorHandler.init());
-			if (response !== void 0) return await endWithResponse();
+		let interceptorHandler;
+		let raise = false;
+		try {
+			if (options.hooks?.init) {
+				const hookResult = options.hooks.init(getHookOptions());
+				if (isThenable(hookResult)) return hookResult.then(afterInit);
+			}
+			return afterInit();
 		} catch (error) {
-			options.logErrors && logger.error(error);
-			response = error;
-			return endWithResponse(true);
+			if (!options.manualUnscope) unscope();
+			throw error;
 		}
-		let args = [];
-		if (options.resolveArgs) try {
-			args = await ci.with("Arguments:resolve", () => options.resolveArgs());
-		} catch (error) {
-			options.logErrors && logger.error(error);
-			response = error;
-			return endWithResponse(true);
+		function afterInit() {
+			const instanceResult = options.getControllerInstance();
+			if (isThenable(instanceResult)) return instanceResult.then((inst) => afterInstance(inst));
+			return afterInstance(instanceResult);
 		}
-		if (interceptorHandler?.countBefore) {
-			response = await ci.with("Interceptors:before", () => interceptorHandler.fireBefore(response));
-			if (response !== void 0) return endWithResponse();
+		function afterInstance(instance) {
+			if (instance) {
+				setControllerContext(instance, options.controllerMethod || "", options.targetPath);
+				ci?.hook(options.handlerType, "Controller:registered");
+			}
+			interceptorHandler = options.getIterceptorHandler();
+			if (interceptorHandler?.count) try {
+				const initResult = ci ? ci.with("Interceptors:before", () => interceptorHandler?.before()) : interceptorHandler?.before();
+				if (isThenable(initResult)) return initResult.then((r) => {
+					response = r;
+					if (response !== void 0) return cleanup();
+					return afterInterceptors(instance);
+				}, handleError);
+				response = initResult;
+				if (response !== void 0) return cleanup();
+			} catch (error) {
+				if (options.logErrors) logger.error(String(error));
+				response = error;
+				raise = true;
+				return cleanup();
+			}
+			return afterInterceptors(instance);
 		}
-		const callControllerMethod = () => {
-			if (options.callControllerMethod) return options.callControllerMethod(args);
-			else if (instance && options.controllerMethod && typeof instance[options.controllerMethod] === "function") return instance[options.controllerMethod](...args);
-		};
-		try {
-			response = await ci.with(`Handler:${options.targetPath}`, {
-				"moost.handler": options.controllerMethod || "",
-				"moost.controller": getConstructor$1(instance).name
-			}, () => callControllerMethod());
-		} catch (error) {
-			options.logErrors && logger.error(error);
-			response = error;
-			return endWithResponse(true);
+		function afterInterceptors(instance) {
+			let args = [];
+			if (options.resolveArgs) try {
+				const argsResult = ci ? ci.with("Arguments:resolve", () => options.resolveArgs?.()) : options.resolveArgs?.();
+				if (isThenable(argsResult)) return argsResult.then((a) => {
+					args = a;
+					return callHandler(instance, args);
+				}, handleError);
+				args = argsResult;
+			} catch (error) {
+				if (options.logErrors) logger.error(String(error));
+				response = error;
+				raise = true;
+				return cleanup();
+			}
+			return callHandler(instance, args);
 		}
-		async function endWithResponse(raise = false) {
-			if (interceptorHandler?.countAfter || interceptorHandler?.countOnError) try {
-				response = await ci.with("Interceptors:after", () => interceptorHandler.fireAfter(response));
+		function callHandler(instance, args) {
+			const invoke = options.callControllerMethod ? () => options.callControllerMethod?.(args) : instance && options.controllerMethod && typeof instance[options.controllerMethod] === "function" ? () => instance[options.controllerMethod](...args) : void 0;
+			try {
+				const handlerResult = ci ? ci.with(handlerSpanName, handlerAttrs, () => invoke?.()) : invoke?.();
+				if (isThenable(handlerResult)) return handlerResult.then((r) => {
+					response = r;
+					return cleanup();
+				}, (error) => {
+					if (options.logErrors) logger.error(error);
+					response = error;
+					raise = true;
+					return cleanup();
+				});
+				response = handlerResult;
 			} catch (error) {
-				options.logErrors && logger.error(error);
-				if (!options.manualUnscope) unscope();
-				throw error;
+				if (options.logErrors) logger.error(error);
+				response = error;
+				raise = true;
+			}
+			return cleanup();
+		}
+		function handleError(error) {
+			if (options.logErrors) logger.error(String(error));
+			response = error;
+			raise = true;
+			return cleanup();
+		}
+		function cleanup() {
+			if (interceptorHandler?.countAfter || interceptorHandler?.countOnError) {
+				const afterResult = ci ? ci.with("Interceptors:after", () => interceptorHandler?.fireAfter(response)) : interceptorHandler?.fireAfter(response);
+				if (isThenable(afterResult)) return afterResult.then((r) => {
+					response = r;
+					return finalize();
+				}, (error) => {
+					if (options.logErrors) logger.error(String(error));
+					if (!options.manualUnscope) unscope();
+					throw error;
+				});
+				response = afterResult;
 			}
+			return finalize();
+		}
+		function finalize() {
 			if (!options.manualUnscope) unscope();
-			if (options.hooks?.end) await options.hooks.end(hookOptions);
+			if (options.hooks?.end) {
+				const endResult = options.hooks.end(getHookOptions());
+				if (isThenable(endResult)) return endResult.then(() => {
+					if (raise) throw response;
+					return response;
+				});
+			}
 			if (raise) throw response;
 			return response;
 		}
-		return endWithResponse();
 	};
 }
 
 //#endregion
 //#region packages/moost/src/binding/utils.ts
-function getInstanceOwnMethods(instance) {
+/** Returns the own method names of an instance, including inherited methods from parent classes. */ function getInstanceOwnMethods(instance) {
 	const proto = Object.getPrototypeOf(instance);
-	return [
+	return [...new Set([
 		...getParentProps(getConstructor$1(instance)),
 		...Object.getOwnPropertyNames(proto),
 		...Object.getOwnPropertyNames(instance)
-	].filter((m) => typeof instance[m] === "function");
+	])].filter((m) => typeof instance[m] === "function");
 }
-function getInstanceOwnProps(instance) {
+/** Returns the own non-method property names of an instance, including inherited properties. */ function getInstanceOwnProps(instance) {
 	const proto = Object.getPrototypeOf(instance);
-	return [
+	return [...new Set([
 		...getParentProps(getConstructor$1(instance)),
 		...Object.getOwnPropertyNames(proto),
 		...Object.getOwnPropertyNames(instance)
-	].filter((m) => typeof instance[m] !== "function");
+	])].filter((m) => typeof instance[m] !== "function");
 }
 const fnProto = Object.getPrototypeOf(Function);
 function getParentProps(constructor) {
@@ -332,99 +467,166 @@ function getParentProps(constructor) {
 }
 
 //#endregion
-//#region packages/moost/src/class-function/class-function.ts
-async function getCallableFn(targetInstance, fn, pipes, logger) {
-	const mate$1 = getMoostMate();
-	const meta = mate$1.read(fn);
-	if (meta?.injectable) {
-		const infact$1 = getMoostInfact();
-		const instance = await infact$1.getForInstance(targetInstance, fn, { customData: { pipes: [...pipes || [], ...meta.pipes || []].sort((a, b) => a.priority - b.priority) } });
-		return (...args) => instance.handler(...args);
-	}
-	if (typeof fn === "function") return fn;
-	const e = /* @__PURE__ */ new Error(`getCallableFn failed for "${getConstructor$1(targetInstance).name}" because the passed arg is not a Function nor TClassFunction`);
-	logger.error(e);
-	throw e;
+//#region packages/moost/src/resolve-arguments.ts
+/**
+* Builds an argument-resolver function from pre-computed per-parameter pipe lists.
+*
+* Returns `undefined` when there are no parameters to resolve.
+* The returned function runs pipes for each parameter and returns
+* `unknown[]` synchronously when possible, or `Promise<unknown[]>` otherwise.
+*/ function resolveArguments(argsPipes, context) {
+	if (argsPipes.length === 0) return void 0;
+	return () => {
+		const args = [];
+		let hasAsync = false;
+		for (let i = 0; i < argsPipes.length; i++) {
+			const { pipes, meta: paramMeta } = argsPipes[i];
+			const result = runPipes(pipes, void 0, {
+				classMeta: context.classMeta,
+				methodMeta: context.methodMeta,
+				paramMeta,
+				type: context.type,
+				key: context.key,
+				index: i,
+				targetMeta: paramMeta,
+				instantiate: (t) => useControllerContext().instantiate(t)
+			}, "PARAM");
+			if (!hasAsync && isThenable(result)) hasAsync = true;
+			args[i] = result;
+		}
+		return hasAsync ? Promise.all(args) : args;
+	};
 }
 
 //#endregion
 //#region packages/moost/src/interceptor-handler.ts
-function _define_property$1(obj, key, value) {
-	if (key in obj) Object.defineProperty(obj, key, {
+function _define_property$1(obj, key$2, value) {
+	if (key$2 in obj) Object.defineProperty(obj, key$2, {
 		value,
 		enumerable: true,
 		configurable: true,
 		writable: true
 	});
-	else obj[key] = value;
+	else obj[key$2] = value;
 	return obj;
 }
-var InterceptorHandler = class {
+/**
+* Manages the before/after/error interceptor lifecycle for a single event.
+* Optimised for the common sync path — only allocates promises when an interceptor goes async.
+*/ var InterceptorHandler = class {
+	getReplyFn() {
+		return this._boundReplyFn ?? (this._boundReplyFn = (reply) => {
+			this.response = reply;
+			this.responseOverwritten = true;
+		});
+	}
 	get count() {
 		return this.handlers.length;
 	}
-	get countBefore() {
-		return this.before.length;
-	}
 	get countAfter() {
-		return this.after.length;
+		return this.after?.length ?? 0;
 	}
 	get countOnError() {
-		return this.onError.length;
+		return this.onError?.length ?? 0;
 	}
-	replyFn(reply) {
-		this.response = reply;
-		this.responseOverwritten = true;
+	/**
+	* Register hooks from a TInterceptorDef.
+	* Returns a pending PromiseLike if `before` went async, or undefined.
+	*/ registerDef(def, entry, ci) {
+		if (def.after) (this.after ?? (this.after = [])).unshift({
+			name: entry.name,
+			fn: def.after
+		});
+		if (def.error) (this.onError ?? (this.onError = [])).unshift({
+			name: entry.name,
+			fn: def.error
+		});
+		if (def.before) {
+			const spanName = entry.spanName;
+			const result = ci ? ci.with(spanName, { "moost.interceptor.stage": "before" }, () => def.before?.(this.getReplyFn())) : def.before(this.getReplyFn());
+			if (isThenable(result)) return result;
+		}
+		return void 0;
 	}
-	async init() {
+	before() {
 		const ci = getContextInjector$1();
-		for (const { handler, name } of this.handlers) {
-			const response = await ci.with(`Interceptor:${name}`, { "moost.interceptor.stage": "init" }, () => handler((fn) => {
-				this.before.push({
-					name,
-					fn
-				});
-			}, (fn) => {
-				this.after.unshift({
-					name,
-					fn
-				});
-			}, (fn) => {
-				this.onError.unshift({
-					name,
-					fn
-				});
-			}));
-			if (response !== void 0) return response;
+		for (let i = 0; i < this.handlers.length; i++) {
+			const entry = this.handlers[i];
+			const { handler } = entry;
+			if (typeof handler === "function") {
+				const factoryResult = handler();
+				if (isThenable(factoryResult)) return this._beforeAsyncFactory(ci, factoryResult, i);
+				const pending = this.registerDef(factoryResult, entry, ci);
+				if (pending) return this._beforeAsyncPending(ci, pending, i);
+				if (this.responseOverwritten) return this.response;
+			} else {
+				const pending = this.registerDef(handler, entry, ci);
+				if (pending) return this._beforeAsyncPending(ci, pending, i);
+				if (this.responseOverwritten) return this.response;
+			}
 		}
 	}
-	async fireBefore(response) {
-		const ci = getContextInjector$1();
+	async _beforeAsyncFactory(ci, factoryPromise, startIndex) {
+		const def = await factoryPromise;
+		const entry = this.handlers[startIndex];
+		const pending = this.registerDef(def, entry, ci);
+		if (pending) await pending;
+		if (this.responseOverwritten) return this.response;
+		return this._beforeFrom(ci, startIndex + 1);
+	}
+	async _beforeAsyncPending(ci, pending, startIndex) {
+		await pending;
+		if (this.responseOverwritten) return this.response;
+		return this._beforeFrom(ci, startIndex + 1);
+	}
+	async _beforeFrom(ci, startIndex) {
+		for (let i = startIndex; i < this.handlers.length; i++) {
+			const entry = this.handlers[i];
+			const { handler } = entry;
+			let def;
+			if (typeof handler === "function") def = await handler();
+			else def = handler;
+			const pending = this.registerDef(def, entry, ci);
+			if (pending) await pending;
+			if (this.responseOverwritten) return this.response;
+		}
+	}
+	fireAfter(response) {
 		this.response = response;
-		for (const { name, fn } of this.before) {
-			await ci.with(`Interceptor:${name}`, { "moost.interceptor.stage": "before" }, () => fn(this.replyFn.bind(this)));
-			if (this.responseOverwritten) break;
+		const isError = response instanceof Error;
+		const handlers = isError ? this.onError : this.after;
+		if (!handlers) return this.response;
+		const ci = getContextInjector$1();
+		const stage = isError ? "onError" : "after";
+		for (let i = 0; i < handlers.length; i++) {
+			const { name, fn } = handlers[i];
+			const result = ci ? ci.with(`Interceptor:${name}`, { "moost.interceptor.stage": stage }, () => fn(response, this.getReplyFn())) : fn(response, this.getReplyFn());
+			if (isThenable(result)) return this._fireAfterAsync({
+				ci,
+				handlers,
+				stage,
+				response
+			}, result, i);
 		}
 		return this.response;
 	}
-	async fireAfter(response) {
-		const ci = getContextInjector$1();
-		this.response = response;
-		if (response instanceof Error) for (const { name, fn } of this.onError) await ci.with(`Interceptor:${name}`, { "moost.interceptor.stage": "after" }, () => fn(response, this.replyFn.bind(this)));
-		else for (const { name, fn } of this.after) await ci.with(`Interceptor:${name}`, { "moost.interceptor.stage": "onError" }, () => fn(response, this.replyFn.bind(this)));
+	async _fireAfterAsync(ctx, pending, startIndex) {
+		await pending;
+		for (let i = startIndex + 1; i < ctx.handlers.length; i++) {
+			const { name, fn } = ctx.handlers[i];
+			if (ctx.ci) await ctx.ci.with(`Interceptor:${name}`, { "moost.interceptor.stage": ctx.stage }, () => fn(ctx.response, this.getReplyFn()));
+			else await fn(ctx.response, this.getReplyFn());
+		}
 		return this.response;
 	}
 	constructor(handlers) {
 		_define_property$1(this, "handlers", void 0);
-		_define_property$1(this, "before", void 0);
 		_define_property$1(this, "after", void 0);
 		_define_property$1(this, "onError", void 0);
 		_define_property$1(this, "response", void 0);
 		_define_property$1(this, "responseOverwritten", void 0);
+		_define_property$1(this, "_boundReplyFn", void 0);
 		this.handlers = handlers;
-		this.before = [];
-		this.after = [];
-		this.onError = [];
 		this.responseOverwritten = false;
 	}
 };
@@ -432,25 +634,129 @@ var InterceptorHandler = class {
 //#endregion
 //#region packages/moost/src/utils.ts
 const mate = getMoostMate();
-function getIterceptorHandlerFactory(interceptors, getTargetInstance, pipes, logger) {
+const noInterceptors = () => void 0;
+function findInterceptorMethods(handler) {
+	const fakeInstance = Object.create(handler.prototype);
+	const methods = getInstanceOwnMethods(fakeInstance);
+	const result = {};
+	for (const method of methods) {
+		const methodMeta = mate.read(fakeInstance, method);
+		const hook = methodMeta?.interceptorHook;
+		if (hook === "before" || hook === "after" || hook === "error") result[hook] = method;
+	}
+	return result;
+}
+function buildMethodResolver(opts) {
+	const fakeInstance = Object.create(opts.handler.prototype);
+	const methodMeta = mate.read(fakeInstance, opts.methodName) || {};
+	const argsPipes = [];
+	for (const p of methodMeta.params || []) argsPipes.push({
+		meta: p,
+		pipes: mergeSorted(opts.pipes, p.pipes)
+	});
+	if (argsPipes.length === 0) return void 0;
+	return resolveArguments(argsPipes, {
+		classMeta: opts.classMeta,
+		methodMeta,
+		type: opts.handler,
+		key: opts.methodName
+	});
+}
+function callWithArgs(instance, methodName, resolveArgs) {
+	const ci = getContextInjector$1();
+	const args = ci ? ci.with("Arguments:resolve", resolveArgs) : resolveArgs();
+	if (isThenable(args)) return args.then((a) => instance[methodName](...a));
+	return instance[methodName](...args);
+}
+function callMethod(instance, methodName, resolveArgs) {
+	if (resolveArgs) return callWithArgs(instance, methodName, resolveArgs);
+	return instance[methodName]();
+}
+function createClassInterceptorFactory(opts) {
+	const infact = getMoostInfact();
+	function buildDef(instance) {
+		const def = {};
+		if (opts.methods.before) {
+			const methodName = opts.methods.before;
+			const resolveArgs = opts.resolvers[methodName];
+			if (resolveArgs) def.before = (reply) => {
+				setOvertake(reply);
+				return callWithArgs(instance, methodName, resolveArgs);
+			};
+			else def.before = () => instance[methodName]();
+		}
+		if (opts.methods.after) {
+			const methodName = opts.methods.after;
+			const resolveArgs = opts.resolvers[methodName];
+			def.after = (response, reply) => {
+				setOvertake(reply);
+				setInterceptResult(response);
+				return callMethod(instance, methodName, resolveArgs);
+			};
+		}
+		if (opts.methods.error) {
+			const methodName = opts.methods.error;
+			const resolveArgs = opts.resolvers[methodName];
+			def.error = (error, reply) => {
+				setOvertake(reply);
+				setInterceptResult(error);
+				return callMethod(instance, methodName, resolveArgs);
+			};
+		}
+		return def;
+	}
+	function fromTarget(targetInstance) {
+		const result = infact.getForInstance(targetInstance, opts.handler, { customData: { pipes: opts.pipes } });
+		if (isThenable(result)) return result.then(buildDef);
+		return buildDef(result);
+	}
 	return () => {
-		const interceptorHandlers = [];
-		for (const { handler, name } of interceptors) {
-			const interceptorMeta = mate.read(handler);
-			if (interceptorMeta?.injectable) interceptorHandlers.push({
-				handler: async (...args) => {
-					const targetInstance = await getTargetInstance();
-					return (await getCallableFn(targetInstance, handler, pipes, logger))(...args);
-				},
-				name
-			});
-			else interceptorHandlers.push({
+		const result = opts.getTargetInstance();
+		if (isThenable(result)) return result.then(fromTarget);
+		return fromTarget(result);
+	};
+}
+function getIterceptorHandlerFactory(interceptors, getTargetInstance, pipes) {
+	if (interceptors.length === 0) return noInterceptors;
+	const precomputedHandlers = interceptors.map(({ handler, name }) => {
+		const spanName = `Interceptor:${name}`;
+		if (typeof handler !== "function") return {
+			handler,
+			name,
+			spanName
+		};
+		const interceptorMeta = mate.read(handler);
+		if (!interceptorMeta?.interceptor) throw new Error(`Invalid interceptor "${name}": must be TInterceptorDef or @Interceptor class`);
+		const classMeta = interceptorMeta;
+		const methods = findInterceptorMethods(handler);
+		const mergedPipes = mergeSorted(pipes, classMeta.pipes);
+		const resolvers = {};
+		for (const hook of [
+			"before",
+			"after",
+			"error"
+		]) {
+			const methodName = methods[hook];
+			if (methodName) resolvers[methodName] = buildMethodResolver({
 				handler,
-				name
+				methodName,
+				pipes: mergedPipes,
+				classMeta
 			});
 		}
-		return Promise.resolve(new InterceptorHandler(interceptorHandlers));
-	};
+		return {
+			handler: createClassInterceptorFactory({
+				handler,
+				methods,
+				resolvers,
+				getTargetInstance,
+				pipes: mergedPipes
+			}),
+			name,
+			spanName
+		};
+	});
+	return () => new InterceptorHandler(precomputedHandlers);
 }
 
 //#endregion
@@ -477,32 +783,20 @@ async function bindControllerMethods(options) {
 	for (const method of methods) {
 		const methodMeta = getMoostMate().read(fakeInstance, method) || {};
 		if (!methodMeta.handlers?.length) continue;
-		const pipes = [...opts.pipes || [], ...methodMeta.pipes || []].sort((a, b) => a.priority - b.priority);
-		const interceptors = [
-			...opts.interceptors || [],
-			...meta.interceptors || [],
-			...methodMeta.interceptors || []
-		].sort((a, b) => a.priority - b.priority);
-		const getIterceptorHandler = getIterceptorHandlerFactory(interceptors, getInstance, pipes, options.logger);
+		const pipes = mergeSorted(opts.pipes, methodMeta.pipes);
+		const interceptors = mergeSorted(opts.interceptors, meta.interceptors, methodMeta.interceptors);
+		const getIterceptorHandler = getIterceptorHandlerFactory(interceptors, getInstance, pipes);
 		const argsPipes = [];
 		for (const p of methodMeta.params || []) argsPipes.push({
 			meta: p,
-			pipes: [...pipes, ...p.pipes || []].sort((a, b) => a.priority - b.priority)
+			pipes: mergeSorted(pipes, p.pipes)
+		});
+		const resolveArgs = resolveArguments(argsPipes, {
+			classMeta: meta,
+			methodMeta,
+			type: classConstructor,
+			key: method
 		});
-		const resolveArgs = async () => {
-			const args = [];
-			for (const [i, { pipes: pipes$1, meta: paramMeta }] of argsPipes.entries()) args[i] = await runPipes(pipes$1, void 0, {
-				classMeta: meta,
-				methodMeta,
-				paramMeta,
-				type: classConstructor,
-				key: method,
-				index: i,
-				targetMeta: paramMeta,
-				instantiate: (t) => useControllerContext().instantiate(t)
-			}, "PARAM");
-			return args;
-		};
 		const wm = /* @__PURE__ */ new WeakMap();
 		controllerOverview.handlers.push(...methodMeta.handlers.map((h) => {
 			const data = {
@@ -524,6 +818,7 @@ async function bindControllerMethods(options) {
 			handlers: methodMeta.handlers,
 			getIterceptorHandler,
 			resolveArgs,
+			controllerName: classConstructor.name,
 			logHandler: (eventName) => {
 				options.moostInstance.logMappedHandler(eventName, classConstructor, method);
 			},
@@ -541,7 +836,19 @@ async function bindControllerMethods(options) {
 
 //#endregion
 //#region packages/moost/src/decorators/circular.decorator.ts
-function Circular(resolver) {
+/**
+* Marks a constructor parameter dependency as circular.
+* The resolver function is called lazily to break the circular reference.
+*
+* @param resolver - Factory that returns the class constructor (e.g. `() => MyService`).
+*
+* @example
+* ```ts
+* class ServiceA {
+*   constructor(@Circular(() => ServiceB) private b: ServiceB) {}
+* }
+* ```
+*/ function Circular(resolver) {
 	return getMoostMate().decorate("circular", resolver);
 }
 
@@ -609,10 +916,10 @@ function Circular(resolver) {
 * Stores Required metadata
 */ function Required() {
 	const mate$1 = getMoostMate();
-	return mate$1.apply(mate$1.decorate("required", true), mate$1.decorateClass((meta, level, key, index) => {
-		if (typeof index !== "number" && meta && ["string", "symbol"].includes(typeof key)) {
+	return mate$1.apply(mate$1.decorate("required", true), mate$1.decorateClass((meta, level, key$2, index) => {
+		if (typeof index !== "number" && meta && ["string", "symbol"].includes(typeof key$2)) {
 			meta.requiredProps = meta.requiredProps || [];
-			meta.requiredProps.push(key);
+			meta.requiredProps.push(key$2);
 		}
 		return meta;
 	}));
@@ -679,15 +986,24 @@ var TInterceptorPriority = /* @__PURE__ */ function(TInterceptorPriority$1) {
 /**
 * ## Intercept
 * ### @Decorator
-* Set interceptor
-* @param handler interceptor fn (use defineInterceptorFn)
-* @param priority interceptor priority
-* @returns
+* Attach an interceptor to a class or method.
+* @param handler — @Interceptor class constructor or TInterceptorDef object
+* @param priority — interceptor priority (overrides handler's own priority)
+* @param name — interceptor name for tracing
 */ function Intercept(handler, priority, name) {
-	return getMoostMate().decorate("interceptors", {
+	const mate$1 = getMoostMate();
+	if (typeof handler === "function") {
+		const interceptorMeta = mate$1.read(handler);
+		return mate$1.decorate("interceptors", {
+			handler,
+			priority: priority ?? interceptorMeta?.interceptor?.priority ?? 4,
+			name: name || handler.name || "<anonymous>"
+		}, true);
+	}
+	return mate$1.decorate("interceptors", {
 		handler,
-		priority: priority || handler.priority || 4,
-		name: name || handler._name || handler.name
+		priority: priority ?? handler.priority ?? 4,
+		name: name || handler._name || "<anonymous>"
 	}, true);
 }
 
@@ -700,14 +1016,14 @@ var TInterceptorPriority = /* @__PURE__ */ function(TInterceptorPriority$1) {
 * @param label - field label
 * @paramType unknown
 */ function Resolve(resolver, label) {
-	return (target, key, index) => {
+	return (target, key$2, index) => {
 		const i = typeof index === "number" ? index : void 0;
 		getMoostMate().decorate("resolver", (metas, level) => {
 			let newLabel = label;
 			if (!newLabel && level === "PROP" && typeof metas.key === "string") newLabel = metas.key;
-			fillLabel(target, key || "", i, newLabel);
+			fillLabel(target, key$2 || "", i, newLabel);
 			return resolver(metas, level);
-		})(target, key, i);
+		})(target, key$2, i);
 	};
 }
 /**
@@ -743,23 +1059,90 @@ var TInterceptorPriority = /* @__PURE__ */ function(TInterceptorPriority$1) {
 */ function ConstFactory(factory, label) {
 	return Resolve(async () => factory(), label);
 }
-function fillLabel(target, key, index, name) {
+function fillLabel(target, key$2, index, name) {
 	if (name) {
-		const meta = getMoostMate().read(target, key);
+		const meta = getMoostMate().read(target, key$2);
 		if (typeof index === "number") {
-			if (!meta?.params?.[index]?.label) Label(name)(target, key, index);
-		} else if (!meta?.label) Label(name)(target, key);
+			if (!meta?.params?.[index]?.label) Label(name)(target, key$2, index);
+		} else if (!meta?.label) Label(name)(target, key$2);
 	}
 }
 
+//#endregion
+//#region packages/moost/src/decorators/interceptor.decorator.ts
+/**
+* ## @Interceptor
+* ### Class Decorator
+* Marks a class as a decorator-based interceptor.
+* Auto-adds @Injectable() if not already present.
+*
+* Use @Before(), @After(), and @OnError() method decorators
+* to register lifecycle hooks.
+*
+* @param priority — interceptor priority (default: INTERCEPTOR)
+* @param scope — DI scope ('FOR_EVENT' | 'SINGLETON' | true)
+*/ function Interceptor(priority, scope) {
+	const mate$1 = getMoostMate();
+	const decorators = [insureInjectable, mate$1.decorate("interceptor", { priority: priority ?? TInterceptorPriority.INTERCEPTOR })];
+	if (scope) decorators.push(mate$1.decorate("injectable", scope));
+	return mate$1.apply(...decorators);
+}
+/**
+* ## @Before
+* ### Method Decorator
+* Marks a method as a before-phase interceptor hook.
+* Runs before argument resolution and handler execution.
+* Use @Overtake() param to get the reply fn for short-circuiting.
+*/ function Before() {
+	return getMoostMate().decorate("interceptorHook", "before");
+}
+/**
+* ## @After
+* ### Method Decorator
+* Marks a method as an after-phase interceptor hook.
+* Runs after successful handler execution.
+* Use @Response() param for the handler result, @Overtake() for the reply fn.
+*/ function After() {
+	return getMoostMate().decorate("interceptorHook", "after");
+}
+/**
+* ## @OnError
+* ### Method Decorator
+* Marks a method as an error-phase interceptor hook.
+* Runs when the handler throws or returns an Error.
+* Use @Response() param for the error, @Overtake() for the reply fn.
+*/ function OnError() {
+	return getMoostMate().decorate("interceptorHook", "error");
+}
+/**
+* ## @Overtake
+* ### Parameter Decorator
+* Injects the reply function into an interceptor method parameter.
+* Call the reply fn to short-circuit the handler or replace the response.
+*/ function Overtake() {
+	return Resolve(() => useOvertake(), "overtake");
+}
+/**
+* ## @Response
+* ### Parameter Decorator
+* Injects the handler result into an interceptor method parameter.
+* In @After methods, this is the successful response.
+* In @OnError methods, this is the Error that was thrown.
+*/ function Response() {
+	return Resolve(() => useInterceptResult(), "response");
+}
+
 //#endregion
 //#region packages/moost/src/decorators/logger.decorator.ts
 /**
 * Resolves event logger from event context
 * @param topic
-* @returns Resolver to '@wooksjs/event-core' (EventLogger)
+* @returns Resolver to '@wooksjs/event-core' (Logger)
 */ function InjectEventLogger(topic) {
-	return Resolve(() => useEventLogger$1(topic));
+	return Resolve(() => {
+		const l = useLogger$1();
+		return topic && typeof l.topic === "function" ? l.topic(topic) : l;
+	});
 }
 /**
 * Resolves app-level logger
@@ -784,7 +1167,7 @@ function fillLabel(target, key, index, name) {
 
 //#endregion
 //#region packages/moost/src/pipes/types.ts
-var TPipePriority = /* @__PURE__ */ function(TPipePriority$1) {
+/** Execution priority for pipes. Lower values run first. */ var TPipePriority = /* @__PURE__ */ function(TPipePriority$1) {
 	TPipePriority$1[TPipePriority$1["BEFORE_RESOLVE"] = 0] = "BEFORE_RESOLVE";
 	TPipePriority$1[TPipePriority$1["RESOLVE"] = 1] = "RESOLVE";
 	TPipePriority$1[TPipePriority$1["AFTER_RESOLVE"] = 2] = "AFTER_RESOLVE";
@@ -872,31 +1255,73 @@ var TPipePriority = /* @__PURE__ */ function(TPipePriority$1) {
 //#endregion
 //#region packages/moost/src/define.ts
 /**
-* ### Define Interceptor Function
+* Define a before-phase interceptor.
+*
+* Runs before argument resolution and handler execution.
+* Call `reply(value)` to short-circuit the handler and respond early.
 *
+* @example
 * ```ts
-* defineInterceptorFn((before, after, onError) => {
-*         //init
-*         before(() => {
-*              // before handler
-*         })
-*         after((response, reply) => {
-*              // after handler
-*         })
-*         onError((error, reply) => {
-*              // when error occured
-*         })
-*     },
-*     TInterceptorPriority.INTERCEPTOR,
-* )
+* const authGuard = defineBeforeInterceptor((reply) => {
+*   if (!isAuthenticated()) reply(new HttpError(401))
+* }, TInterceptorPriority.GUARD)
 * ```
+*/ function defineBeforeInterceptor(fn, priority = TInterceptorPriority.INTERCEPTOR) {
+	return {
+		before: fn,
+		priority
+	};
+}
+/**
+* Define an after-phase interceptor.
 *
-* @param fn interceptor function
-* @param priority priority of the interceptor where BEFORE_ALL = 0, BEFORE_GUARD = 1, GUARD = 2, AFTER_GUARD = 3, INTERCEPTOR = 4, CATCH_ERROR = 5, AFTER_ALL = 6
-* @returns
-*/ function defineInterceptorFn(fn, priority = TInterceptorPriority.INTERCEPTOR) {
-	fn.priority = priority;
-	return fn;
+* Runs after successful handler execution.
+* Call `reply(value)` to transform/replace the response.
+*
+* @example
+* ```ts
+* const setHeader = defineAfterInterceptor(() => {
+*   useResponse().setHeader('x-server', 'my-server')
+* }, TInterceptorPriority.AFTER_ALL)
+* ```
+*/ function defineAfterInterceptor(fn, priority = TInterceptorPriority.AFTER_ALL) {
+	return {
+		after: fn,
+		priority
+	};
+}
+/**
+* Define an error-phase interceptor.
+*
+* Runs when the handler throws or returns an Error.
+* Call `reply(value)` to recover from the error with a replacement response.
+*
+* @example
+* ```ts
+* const errorFormatter = defineErrorInterceptor((error, reply) => {
+*   reply({ message: error.message, status: 500 })
+* }, TInterceptorPriority.CATCH_ERROR)
+* ```
+*/ function defineErrorInterceptor(fn, priority = TInterceptorPriority.CATCH_ERROR) {
+	return {
+		error: fn,
+		priority
+	};
+}
+/**
+* Define a full interceptor with multiple lifecycle hooks.
+*
+* @example
+* ```ts
+* const myInterceptor = defineInterceptor({
+*   before(reply) { ... },
+*   after(response, reply) { ... },
+*   error(error, reply) { ... },
+* }, TInterceptorPriority.INTERCEPTOR)
+* ```
+*/ function defineInterceptor(def, priority = TInterceptorPriority.INTERCEPTOR) {
+	def.priority = priority;
+	return def;
 }
 /**
 * ### Define Pipe Function
@@ -910,8 +1335,8 @@ var TPipePriority = /* @__PURE__ */ function(TPipePriority$1) {
 * )
 * ```
 *
-* @param fn interceptor function
-* @param priority priority of the pipe where BEFORE_RESOLVE = 0, RESOLVE = 1, AFTER_RESOLVE = 2, BEFORE_TRANSFORM = 3, TRANSFORM = 4, AFTER_TRANSFORM = 5, BEFORE_VALIDATE = 6, VALIDATE = 7, AFTER_VALIDATE = 8
+* @param fn pipe function
+* @param priority priority of the pipe
 * @returns
 */ function definePipeFn(fn, priority = TPipePriority.TRANSFORM) {
 	fn.priority = priority;
@@ -935,14 +1360,14 @@ const sharedPipes = [{
 
 //#endregion
 //#region packages/moost/src/moost.ts
-function _define_property(obj, key, value) {
-	if (key in obj) Object.defineProperty(obj, key, {
+function _define_property(obj, key$2, value) {
+	if (key$2 in obj) Object.defineProperty(obj, key$2, {
 		value,
 		enumerable: true,
 		configurable: true,
 		writable: true
 	});
-	else obj[key] = value;
+	else obj[key$2] = value;
 	return obj;
 }
 /**
@@ -1061,27 +1486,24 @@ function _define_property(obj, key, value) {
 	async bindController(controller, provide, replace, globalPrefix, replaceOwnPrefix) {
 		const mate$1 = getMoostMate();
 		const classMeta = mate$1.read(controller);
-		const infact$1 = getMoostInfact();
+		const infact = getMoostInfact();
 		const isControllerConsructor = isConstructor$1(controller);
-		const pipes = [...this.pipes, ...classMeta?.pipes || []].sort((a, b) => a.priority - b.priority);
+		const pipes = mergeSorted(this.pipes, classMeta?.pipes);
 		let instance;
 		const infactOpts = {
 			provide,
 			replace,
 			customData: { pipes }
 		};
-		if (isControllerConsructor && (classMeta?.injectable === "SINGLETON" || classMeta?.injectable === true)) await createAsyncEventContext({
-			event: { type: "init" },
-			options: {}
-		})(async () => {
+		if (isControllerConsructor && (classMeta?.injectable === "SINGLETON" || classMeta?.injectable === true)) await createEventContext$1({ logger: this.logger }, async () => {
 			setControllerContext(this, "bindController", "");
-			instance = await infact$1.get(controller, infactOpts);
+			instance = await infact.get(controller, infactOpts);
 		});
 		else if (!isControllerConsructor) {
 			instance = controller;
-			infact$1.setInstanceRegistries(instance, provide, replace, { pipes });
+			infact.setInstanceRegistries(instance, provide, replace, { pipes });
 		}
-		const getInstance = instance ? () => Promise.resolve(instance) : async () => await infact$1.get(controller, { ...infactOpts });
+		const getInstance = instance ? () => instance : async () => await infact.get(controller, { ...infactOpts });
 		const classConstructor = isConstructor$1(controller) ? controller : getConstructor$1(controller);
 		this.controllersOverview.push(await bindControllerMethods({
 			getInstance,
@@ -1137,22 +1559,26 @@ function _define_property(obj, key, value) {
 		if (!this.globalInterceptorHandler) {
 			const mate$1 = getMoostMate();
 			const thisMeta = mate$1.read(this);
-			const pipes = [...this.pipes || [], ...thisMeta?.pipes || []].sort((a, b) => a.priority - b.priority);
-			const interceptors = [...this.interceptors, ...thisMeta?.interceptors || []].sort((a, b) => a.priority - b.priority);
-			this.globalInterceptorHandler = getIterceptorHandlerFactory(interceptors, () => Promise.resolve(this), pipes, this.logger);
+			const pipes = mergeSorted(this.pipes, thisMeta?.pipes);
+			const interceptors = mergeSorted(this.interceptors, thisMeta?.interceptors);
+			this.globalInterceptorHandler = getIterceptorHandlerFactory(interceptors, () => this, pipes);
 		}
 		return this.globalInterceptorHandler();
 	}
 	applyGlobalInterceptors(...items) {
-		for (const item of items) if (typeof item === "function") this.interceptors.push({
-			handler: item,
-			priority: typeof item.priority === "number" ? item.priority : TInterceptorPriority.INTERCEPTOR,
-			name: item._name || item.name || "<anonymous>"
-		});
+		const mate$1 = getMoostMate();
+		for (const item of items) if (typeof item === "function") {
+			const meta = mate$1.read(item);
+			this.interceptors.push({
+				handler: item,
+				priority: meta?.interceptor?.priority ?? TInterceptorPriority.INTERCEPTOR,
+				name: item.name || "<anonymous>"
+			});
+		} else if ("handler" in item) this.interceptors.push(item);
 		else this.interceptors.push({
-			handler: item.handler,
-			priority: item.priority,
-			name: item.name || item.handler._name || item.handler.name || "<anonymous>"
+			handler: item,
+			priority: item.priority ?? TInterceptorPriority.INTERCEPTOR,
+			name: item._name || "<anonymous>"
 		});
 		this.globalInterceptorHandler = void 0;
 		return this;
@@ -1202,4 +1628,4 @@ function _define_property(obj, key, value) {
 };
 
 //#endregion
-export { ApplyDecorators, Circular, Const, ConstFactory, ContextInjector, Controller, Description, EventLogger, Id, ImportController, Inherit, Inject, InjectEventLogger, InjectFromScope, InjectMoostLogger, InjectScopeVars, Injectable, Intercept, InterceptorHandler, Label, LoggerTopic, Moost, Optional, Param, Params, Pipe, ProstoLogger, Provide, Replace, Required, Resolve, TInterceptorPriority, TPipePriority, Value, clearGlobalWooks, createLogger, createProvideRegistry, createReplaceRegistry, defineInfactScope, defineInterceptorFn, defineMoostEventHandler, definePipeFn, getConstructor, getContextInjector, getGlobalWooks, getInfactScopeVars, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, isConstructor, loggerConsoleTransport, registerEventScope, replaceContextInjector, resolvePipe, setControllerContext, setInfactLoggingOptions, useAsyncEventContext, useControllerContext, useEventLogger };
+export { After, ApplyDecorators, Before, Circular, Const, ConstFactory, ContextInjector, Controller, Description, Id, ImportController, Inherit, Inject, InjectEventLogger, InjectFromScope, InjectMoostLogger, InjectScopeVars, Injectable, Intercept, Interceptor, InterceptorHandler, Label, LoggerTopic, Moost, OnError, Optional, Overtake, Param, Params, Pipe, ProstoLogger, Provide, Replace, Required, Resolve, Response, TInterceptorPriority, TPipePriority, Value, cached, clearGlobalWooks, createEventContext, createLogger, createProvideRegistry, createReplaceRegistry, current, defineAfterInterceptor, defineBeforeInterceptor, defineErrorInterceptor, defineInfactScope, defineInterceptor, defineMoostEventHandler, definePipeFn, eventTypeKey, getConstructor, getContextInjector, getGlobalWooks, getInfactScopeVars, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, isConstructor, isThenable, key, loggerConsoleTransport, mergeSorted, registerEventScope, replaceContextInjector, resetContextInjector, resolvePipe, run, setControllerContext, setInfactLoggingOptions, setInterceptResult, setOvertake, useControllerContext, useInterceptResult, useLogger, useOvertake, useScopeId };