moost 0.6.18 → 0.6.21

package/dist/index.mjs

@@ -214,12 +214,27 @@ const scopeVarsMap = /* @__PURE__ */ new Map();
 	});
 }
 
+//#endregion
+//#region packages/moost/src/composables/global-key.ts
+var _g;
+const registry = (_g = globalThis).__moost_keys ?? (_g.__moost_keys = /* @__PURE__ */ new Map());
+/**
+* Creates a typed event-context key that stays a single instance across duplicate
+* moost loads (dual ESM/CJS, or duplicate installs). Use this for every
+* moost-owned context key instead of `key()` directly.
+*
+* @param name - Debug label AND the registry lookup key; must be unique per slot.
+*/ function globalKey(name) {
+	if (!registry.has(name)) registry.set(name, key$1(name));
+	return registry.get(name);
+}
+
 //#endregion
 //#region packages/moost/src/composables/controller.composable.ts
-const controllerInstanceKey = key$1("controller.instance");
-const controllerMethodKey = key$1("controller.method");
-const controllerRouteKey = key$1("controller.route");
-const controllerPrefixKey = key$1("controller.prefix");
+const controllerInstanceKey = globalKey("controller.instance");
+const controllerMethodKey = globalKey("controller.method");
+const controllerRouteKey = globalKey("controller.route");
+const controllerPrefixKey = globalKey("controller.prefix");
 /**
 * Sets the controller context for the current event scope.
 * Called internally by adapters when dispatching events to handlers.
@@ -261,10 +276,8 @@ const controllerPrefixKey = key$1("controller.prefix");
 
 //#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"));
+const overtakeKey = globalKey("interceptor.overtake");
+const interceptResultKey = globalKey("interceptor.result");
 /** Stores the overtake (reply) function in the current event context. */ function setOvertake(fn, ctx) {
 	(ctx || current$1()).set(overtakeKey, fn);
 }
@@ -466,432 +479,68 @@ function getParentProps(constructor) {
 }
 
 //#endregion
-//#region packages/moost/src/resolve-arguments.ts
+//#region packages/moost/src/decorators/circular.decorator.ts
 /**
-* Builds an argument-resolver function from pre-computed per-parameter pipe lists.
+* Marks a constructor parameter dependency as circular.
+* The resolver function is called lazily to break the circular reference.
 *
-* 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;
-	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;
-	};
+* @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);
 }
 
 //#endregion
-//#region packages/moost/src/interceptor-handler.ts
-function _define_property$1(obj, key, value) {
-	if (key in obj) Object.defineProperty(obj, key, {
-		value,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-	else obj[key] = value;
-	return obj;
+//#region packages/moost/src/decorators/common.decorator.ts
+/**
+* Apply Multiple Decorators
+*
+* @param decorators - array of decorators
+* @returns
+*/ function ApplyDecorators(...decorators) {
+	return getMoostMate().apply(...decorators);
 }
 /**
-* 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 countAfter() {
-		return this.after?.length ?? 0;
-	}
-	get countOnError() {
-		return this.onError?.length ?? 0;
-	}
-	/**
-	* 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;
-		}
-	}
-	before() {
-		const ci = getContextInjector$1();
-		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 _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;
-		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 _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, "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.responseOverwritten = false;
-	}
-};
-
-//#endregion
-//#region packages/moost/src/utils.ts
-const mate = getMoostMate();
-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 hook = mate.read(fakeInstance, method)?.interceptorHook;
-		if (hook === "before" || hook === "after" || hook === "error") result[hook] = method;
-	}
-	return result;
+* ## Label
+* ### @Decorator
+* _Common purpose decorator that may be used by various adapters for various purposes_
+*
+* Stores Label metadata
+*/ function Label(value) {
+	return getMoostMate().decorate("label", value);
 }
-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;
-	return resolveArguments(argsPipes, {
-		classMeta: opts.classMeta,
-		methodMeta,
-		type: opts.handler,
-		key: opts.methodName
-	});
+/**
+* ## Description
+* ### @Decorator
+* _Common purpose decorator that may be used by various adapters for various purposes_
+*
+* Stores Description metadata
+*/ function Description(value) {
+	return getMoostMate().decorate("description", value);
 }
-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);
+/**
+* ## Value
+* ### @Decorator
+* _Common purpose decorator that may be used by various adapters for various purposes_
+*
+* Stores Value metadata
+*/ function Value(value) {
+	return getMoostMate().decorate("value", value);
 }
-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 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,
-				methodName,
-				pipes: mergedPipes,
-				classMeta
-			});
-		}
-		return {
-			handler: createClassInterceptorFactory({
-				handler,
-				methods,
-				resolvers,
-				getTargetInstance,
-				pipes: mergedPipes
-			}),
-			name,
-			spanName
-		};
-	});
-	return () => new InterceptorHandler(precomputedHandlers);
-}
-
-//#endregion
-//#region packages/moost/src/binding/bind-controller.ts
-async function bindControllerMethods(options) {
-	const opts = options || {};
-	const { getInstance } = opts;
-	const { classConstructor } = opts;
-	const { adapters } = opts;
-	opts.globalPrefix = opts.globalPrefix || "";
-	opts.provide = opts.provide || {};
-	const fakeInstance = Object.create(classConstructor.prototype);
-	const methods = getInstanceOwnMethods(fakeInstance);
-	const meta = getMoostMate().read(classConstructor) || {};
-	const ownPrefix = typeof opts.replaceOwnPrefix === "string" ? opts.replaceOwnPrefix : meta.controller?.prefix || "";
-	const prefix = `${opts.globalPrefix}/${ownPrefix}`;
-	const controllerOverview = {
-		meta,
-		computedPrefix: prefix,
-		type: classConstructor,
-		handlers: []
-	};
-	for (const method of methods) {
-		const methodMeta = getMoostMate().read(fakeInstance, method) || {};
-		if (!methodMeta.handlers?.length) continue;
-		const pipes = mergeSorted(opts.pipes, methodMeta.pipes);
-		const getIterceptorHandler = getIterceptorHandlerFactory(mergeSorted(opts.interceptors, meta.interceptors, methodMeta.interceptors), getInstance, pipes);
-		const argsPipes = [];
-		for (const p of methodMeta.params || []) argsPipes.push({
-			meta: p,
-			pipes: mergeSorted(pipes, p.pipes)
-		});
-		const resolveArgs = resolveArguments(argsPipes, {
-			classMeta: meta,
-			methodMeta,
-			type: classConstructor,
-			key: method
-		});
-		const wm = /* @__PURE__ */ new WeakMap();
-		controllerOverview.handlers.push(...methodMeta.handlers.map((h) => {
-			const data = {
-				meta: methodMeta,
-				path: h.path,
-				type: h.type,
-				method,
-				handler: h,
-				registeredAs: []
-			};
-			wm.set(h, data);
-			return data;
-		}));
-		for (const adapter of adapters) await adapter.bindHandler({
-			prefix,
-			fakeInstance,
-			getInstance,
-			method,
-			handlers: methodMeta.handlers,
-			getIterceptorHandler,
-			resolveArgs,
-			controllerName: classConstructor.name,
-			logHandler: (eventName) => {
-				options.moostInstance.logMappedHandler(eventName, classConstructor, method);
-			},
-			register(h, path, args) {
-				const data = wm.get(h);
-				if (data) data.registeredAs.push({
-					path,
-					args
-				});
-			}
-		});
-	}
-	return controllerOverview;
-}
-
-//#endregion
-//#region packages/moost/src/decorators/circular.decorator.ts
-/**
-* 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);
-}
-
-//#endregion
-//#region packages/moost/src/decorators/common.decorator.ts
-/**
-* Apply Multiple Decorators
-*
-* @param decorators - array of decorators
-* @returns
-*/ function ApplyDecorators(...decorators) {
-	return getMoostMate().apply(...decorators);
-}
-/**
-* ## Label
-* ### @Decorator
-* _Common purpose decorator that may be used by various adapters for various purposes_
-*
-* Stores Label metadata
-*/ function Label(value) {
-	return getMoostMate().decorate("label", value);
-}
-/**
-* ## Description
-* ### @Decorator
-* _Common purpose decorator that may be used by various adapters for various purposes_
-*
-* Stores Description metadata
-*/ function Description(value) {
-	return getMoostMate().decorate("description", value);
-}
-/**
-* ## Value
-* ### @Decorator
-* _Common purpose decorator that may be used by various adapters for various purposes_
-*
-* Stores Value metadata
-*/ function Value(value) {
-	return getMoostMate().decorate("value", value);
-}
-/**
-* ## Id
-* ### @Decorator
-* _Common purpose decorator that may be used by various adapters for various purposes_
-*
-* Stores Id metadata
-*/ function Id(value) {
-	return getMoostMate().decorate("id", value);
+/**
+* ## Id
+* ### @Decorator
+* _Common purpose decorator that may be used by various adapters for various purposes_
+*
+* Stores Id metadata
+*/ function Id(value) {
+	return getMoostMate().decorate("id", value);
 }
 /**
 * ## Optional
@@ -957,69 +606,24 @@ function ImportController(prefix, controller, provide) {
 }
 
 //#endregion
-//#region packages/moost/src/decorators/inherit.decorator.ts
+//#region packages/moost/src/decorators/resolve.decorator.ts
 /**
-* ## Inherit
-* ### @Decorator
-* Inherit metadata from super class
-* @returns
-*/ const Inherit = () => getMoostMate().decorate("inherit", true);
-
-//#endregion
-//#region packages/moost/src/decorators/intercept.decorator.ts
-var TInterceptorPriority = /* @__PURE__ */ function(TInterceptorPriority) {
-	TInterceptorPriority[TInterceptorPriority["BEFORE_ALL"] = 0] = "BEFORE_ALL";
-	TInterceptorPriority[TInterceptorPriority["BEFORE_GUARD"] = 1] = "BEFORE_GUARD";
-	TInterceptorPriority[TInterceptorPriority["GUARD"] = 2] = "GUARD";
-	TInterceptorPriority[TInterceptorPriority["AFTER_GUARD"] = 3] = "AFTER_GUARD";
-	TInterceptorPriority[TInterceptorPriority["INTERCEPTOR"] = 4] = "INTERCEPTOR";
-	TInterceptorPriority[TInterceptorPriority["CATCH_ERROR"] = 5] = "CATCH_ERROR";
-	TInterceptorPriority[TInterceptorPriority["AFTER_ALL"] = 6] = "AFTER_ALL";
-	return TInterceptorPriority;
-}({});
-/**
-* ## Intercept
-* ### @Decorator
-* 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) {
-	const mate = getMoostMate();
-	if (typeof handler === "function") {
-		const interceptorMeta = mate.read(handler);
-		return mate.decorate("interceptors", {
-			handler,
-			priority: priority ?? interceptorMeta?.interceptor?.priority ?? 4,
-			name: name || handler.name || "<anonymous>"
-		}, true);
-	}
-	return mate.decorate("interceptors", {
-		handler,
-		priority: priority ?? handler.priority ?? 4,
-		name: name || handler._name || "<anonymous>"
-	}, true);
-}
-
-//#endregion
-//#region packages/moost/src/decorators/resolve.decorator.ts
-/**
-* Hook to the Response Status
-* @decorator
-* @param resolver - resolver function
-* @param label - field label
-* @paramType unknown
-*/ function Resolve(resolver, label) {
-	return (target, key, 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);
-			return resolver(metas, level);
-		})(target, key, i);
-	};
-}
+* Hook to the Response Status
+* @decorator
+* @param resolver - resolver function
+* @param label - field label
+* @paramType unknown
+*/ function Resolve(resolver, label) {
+	return (target, key, 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);
+			return resolver(metas, level);
+		})(target, key, i);
+	};
+}
 /**
 * Get Param Value from url parh
 * @decorator
@@ -1062,6 +666,122 @@ function fillLabel(target, key, index, name) {
 	}
 }
 
+//#endregion
+//#region packages/moost/src/decorators/handler-paths.decorator.ts
+/**
+* ## HandlerPaths
+* ### @Decorator
+* Injects the actual mounted path(s) (`string[]`) of a handler method on the
+* current controller, read from the post-bind overview. Built for `@MoostInit`
+* method parameters:
+*
+* ```ts
+* @MoostInit()
+* init(@HandlerPaths('refresh') paths: string[]) {
+*   const path = paths[0] // e.g. '/api/auth/refresh'
+* }
+* ```
+*
+* `method` defaults to the current context method (useful inside event handlers);
+* pass it explicitly in `@MoostInit`, where the current method is the init method,
+* not the handler. Returns all distinct paths — see {@link useHandlerPaths}.
+*/ function HandlerPaths(method, opts) {
+	return Resolve(() => useHandlerPaths(method, opts));
+}
+
+//#endregion
+//#region packages/moost/src/decorators/inherit.decorator.ts
+/**
+* ## Inherit
+* ### @Decorator
+* Inherit metadata from super class
+* @returns
+*/ const Inherit = () => getMoostMate().decorate("inherit", true);
+
+//#endregion
+//#region packages/moost/src/decorators/init.decorator.ts
+/**
+* ## MoostInit
+* ### @Decorator
+* Marks a controller method to run **once**, after Moost has bound every
+* controller (so the full `getControllersOverview()` is available) and
+* **before** adapters begin serving.
+*
+* The method runs on the controller's SINGLETON instance inside a synthetic
+* init context. Argument injection goes through the RESOLVE pipe only —
+* constructor injection, `@InjectMoost`, `@Inject`, and other `@Resolve`-based
+* params work; transform/validate pipes and interceptors are **not** applied
+* (init is application setup, not an event). Request-scoped composables
+* (`useRequest`, `useHeaders`, `useRouteParams`, …) are unavailable. Async
+* methods are awaited; a throwing hook rejects `Moost.init()` (fail-fast).
+*
+* Applying `@MoostInit` to a `FOR_EVENT` controller is a configuration error and
+* throws at bind time (there is no singleton instance / event at init).
+*
+* @param opts.priority lower runs first across all `@MoostInit` methods (default 0)
+*
+* @example
+* ```ts
+* │  @Controller('auth')
+* │  export class AuthController {
+* │    constructor(private readonly holder: RefreshPathHolder) {}
+* │
+* │    @MoostInit()
+* │    initRefreshCookiePath(@InjectMoost() moost: Moost) {
+* │      // overview is COMPLETE here — this controller's route is mounted
+* │      this.holder.value = resolveRefreshCookiePath(moost)
+* │    }
+* │  }
+* ```
+*/ function MoostInit(opts) {
+	return getMoostMate().decorate("moostInit", { priority: opts?.priority ?? 0 }, false);
+}
+/**
+* ## InjectMoost
+* ### @Decorator
+* Injects the running {@link Moost} application instance into a method (or
+* constructor) parameter. Intended for `@MoostInit` methods that need the wired
+* app (e.g. `getControllersOverview()`), but works in any DI-resolved position.
+*/ function InjectMoost() {
+	return Resolve(() => resolveMoost());
+}
+
+//#endregion
+//#region packages/moost/src/decorators/intercept.decorator.ts
+var TInterceptorPriority = /* @__PURE__ */ function(TInterceptorPriority) {
+	TInterceptorPriority[TInterceptorPriority["BEFORE_ALL"] = 0] = "BEFORE_ALL";
+	TInterceptorPriority[TInterceptorPriority["BEFORE_GUARD"] = 1] = "BEFORE_GUARD";
+	TInterceptorPriority[TInterceptorPriority["GUARD"] = 2] = "GUARD";
+	TInterceptorPriority[TInterceptorPriority["AFTER_GUARD"] = 3] = "AFTER_GUARD";
+	TInterceptorPriority[TInterceptorPriority["INTERCEPTOR"] = 4] = "INTERCEPTOR";
+	TInterceptorPriority[TInterceptorPriority["CATCH_ERROR"] = 5] = "CATCH_ERROR";
+	TInterceptorPriority[TInterceptorPriority["AFTER_ALL"] = 6] = "AFTER_ALL";
+	return TInterceptorPriority;
+}({});
+/**
+* ## Intercept
+* ### @Decorator
+* 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) {
+	const mate = getMoostMate();
+	if (typeof handler === "function") {
+		const interceptorMeta = mate.read(handler);
+		return mate.decorate("interceptors", {
+			handler,
+			priority: priority ?? interceptorMeta?.interceptor?.priority ?? 4,
+			name: name || handler.name || "<anonymous>"
+		}, true);
+	}
+	return mate.decorate("interceptors", {
+		handler,
+		priority: priority ?? handler.priority ?? 4,
+		name: name || handler._name || "<anonymous>"
+	}, true);
+}
+
 //#endregion
 //#region packages/moost/src/decorators/interceptor.decorator.ts
 /**
@@ -1144,9 +864,7 @@ function fillLabel(target, key, index, name) {
 * @returns
 */ function InjectMoostLogger(topic) {
 	return Resolve(async (metas) => {
-		const { instantiate, getController } = useControllerContext();
-		const controller = getController();
-		const moostApp = controller instanceof Moost ? controller : await instantiate(Moost);
+		const moostApp = await resolveMoost();
 		const meta = metas.classMeta;
 		return moostApp.getLogger(meta?.loggerTopic || topic || meta?.id);
 	});
@@ -1236,119 +954,502 @@ function fillLabel(target, key, index, name) {
 */ function InjectFromScope(name) {
 	return getMoostMate().decorate("fromScope", name);
 }
-/**
-* Inject vars from scope for instances
-* instantiated with `@InjectFromScope` decorator
-*/ function InjectScopeVars(name) {
-	return Resolve(({ scopeId }) => {
-		if (scopeId) return name ? getInfactScopeVars(scopeId)?.[name] : getInfactScopeVars(scopeId);
+/**
+* Inject vars from scope for instances
+* instantiated with `@InjectFromScope` decorator
+*/ function InjectScopeVars(name) {
+	return Resolve(({ scopeId }) => {
+		if (scopeId) return name ? getInfactScopeVars(scopeId)?.[name] : getInfactScopeVars(scopeId);
+	});
+}
+
+//#endregion
+//#region packages/moost/src/define.ts
+/**
+* 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
+* 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.
+*
+* 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
+*
+* ```ts
+* // example of a transform pipe
+* const uppercaseTransformPipe = definePipeFn((value, metas, level) => {
+*         return typeof value === 'string' ? value.toUpperCase() : value
+*     },
+*     TPipePriority.TRANSFORM,
+* )
+* ```
+*
+* @param fn pipe function
+* @param priority priority of the pipe
+* @returns
+*/ function definePipeFn(fn, priority = TPipePriority.TRANSFORM) {
+	fn.priority = priority;
+	return fn;
+}
+
+//#endregion
+//#region packages/moost/src/pipes/resolve.pipe.ts
+const resolvePipe = definePipeFn((_value, metas, level) => {
+	const resolver = metas.targetMeta?.resolver;
+	if (resolver) return resolver(metas, level);
+}, TPipePriority.RESOLVE);
+
+//#endregion
+//#region packages/moost/src/pipes/shared-pipes.ts
+const sharedPipes = [{
+	handler: resolvePipe,
+	priority: TPipePriority.RESOLVE
+}];
+
+//#endregion
+//#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;
+	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, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	else obj[key] = value;
+	return obj;
+}
+/**
+* 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 countAfter() {
+		return this.after?.length ?? 0;
+	}
+	get countOnError() {
+		return this.onError?.length ?? 0;
+	}
+	/**
+	* 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;
+		}
+	}
+	before() {
+		const ci = getContextInjector$1();
+		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 _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;
+		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 _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, "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.responseOverwritten = false;
+	}
+};
+
+//#endregion
+//#region packages/moost/src/utils.ts
+const mate = getMoostMate();
+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 hook = mate.read(fakeInstance, method)?.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;
+	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 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,
+				methodName,
+				pipes: mergedPipes,
+				classMeta
+			});
+		}
+		return {
+			handler: createClassInterceptorFactory({
+				handler,
+				methods,
+				resolvers,
+				getTargetInstance,
+				pipes: mergedPipes
+			}),
+			name,
+			spanName
+		};
 	});
+	return () => new InterceptorHandler(precomputedHandlers);
 }
 
 //#endregion
-//#region packages/moost/src/define.ts
-/**
-* 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
-* 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.
-*
-* 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
+//#region packages/moost/src/binding/bind-controller.ts
+async function bindControllerMethods(options) {
+	const opts = options || {};
+	const { getInstance } = opts;
+	const { classConstructor } = opts;
+	const { adapters } = opts;
+	opts.globalPrefix = opts.globalPrefix || "";
+	opts.provide = opts.provide || {};
+	const fakeInstance = Object.create(classConstructor.prototype);
+	const methods = getInstanceOwnMethods(fakeInstance);
+	const meta = getMoostMate().read(classConstructor) || {};
+	const ownPrefix = typeof opts.replaceOwnPrefix === "string" ? opts.replaceOwnPrefix : meta.controller?.prefix || "";
+	const prefix = `${opts.globalPrefix}/${ownPrefix}`;
+	const controllerOverview = {
+		meta,
+		computedPrefix: prefix,
+		type: classConstructor,
+		handlers: []
 	};
+	for (const method of methods) {
+		const methodMeta = getMoostMate().read(fakeInstance, method) || {};
+		if (methodMeta.moostInit) {
+			if (meta.injectable === "FOR_EVENT") throw new Error(`@MoostInit is not allowed on a FOR_EVENT controller (${classConstructor.name}.${String(method)}). Init hooks run once at boot on the SINGLETON instance; FOR_EVENT controllers have no init-time instance.`);
+			const initArgsPipes = (methodMeta.params || []).map((p) => ({
+				meta: p,
+				pipes: sharedPipes
+			}));
+			options.registerInitHook?.({
+				priority: methodMeta.moostInit.priority,
+				method,
+				computedPrefix: prefix,
+				getInstance,
+				resolveArgs: resolveArguments(initArgsPipes, {
+					classMeta: meta,
+					methodMeta,
+					type: classConstructor,
+					key: method
+				})
+			});
+		}
+		if (!methodMeta.handlers?.length) continue;
+		const pipes = mergeSorted(opts.pipes, methodMeta.pipes);
+		const getIterceptorHandler = getIterceptorHandlerFactory(mergeSorted(opts.interceptors, meta.interceptors, methodMeta.interceptors), getInstance, pipes);
+		const argsPipes = [];
+		for (const p of methodMeta.params || []) argsPipes.push({
+			meta: p,
+			pipes: mergeSorted(pipes, p.pipes)
+		});
+		const resolveArgs = resolveArguments(argsPipes, {
+			classMeta: meta,
+			methodMeta,
+			type: classConstructor,
+			key: method
+		});
+		const wm = /* @__PURE__ */ new WeakMap();
+		controllerOverview.handlers.push(...methodMeta.handlers.map((h) => {
+			const data = {
+				meta: methodMeta,
+				path: h.path,
+				type: h.type,
+				method,
+				handler: h,
+				registeredAs: []
+			};
+			wm.set(h, data);
+			return data;
+		}));
+		for (const adapter of adapters) await adapter.bindHandler({
+			prefix,
+			fakeInstance,
+			getInstance,
+			method,
+			handlers: methodMeta.handlers,
+			getIterceptorHandler,
+			resolveArgs,
+			controllerName: classConstructor.name,
+			logHandler: (eventName) => {
+				options.moostInstance.logMappedHandler(eventName, classConstructor, method);
+			},
+			register(h, path, args) {
+				const data = wm.get(h);
+				if (data) data.registeredAs.push({
+					path,
+					args
+				});
+			}
+		});
+	}
+	return controllerOverview;
 }
-/**
-* 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
-*
-* ```ts
-* // example of a transform pipe
-* const uppercaseTransformPipe = definePipeFn((value, metas, level) => {
-*         return typeof value === 'string' ? value.toUpperCase() : value
-*     },
-*     TPipePriority.TRANSFORM,
-* )
-* ```
-*
-* @param fn pipe function
-* @param priority priority of the pipe
-* @returns
-*/ function definePipeFn(fn, priority = TPipePriority.TRANSFORM) {
-	fn.priority = priority;
-	return fn;
-}
-
-//#endregion
-//#region packages/moost/src/pipes/resolve.pipe.ts
-const resolvePipe = definePipeFn((_value, metas, level) => {
-	const resolver = metas.targetMeta?.resolver;
-	if (resolver) return resolver(metas, level);
-}, TPipePriority.RESOLVE);
-
-//#endregion
-//#region packages/moost/src/pipes/shared-pipes.ts
-const sharedPipes = [{
-	handler: resolvePipe,
-	priority: TPipePriority.RESOLVE
-}];
 
 //#endregion
 //#region packages/moost/src/moost.ts
@@ -1440,6 +1541,29 @@ function _define_property(obj, key, value) {
 		return this.controllersOverview;
 	}
 	/**
+	* @internal Memoized index of the controllers overview (controller class →
+	* method name → handler records), built once and reused for fast handler
+	* lookups (see `getHandlerPaths`). Rebuilt whenever controllers are (re)bound.
+	*/ getHandlerOverviewIndex() {
+		if (!this.handlerOverviewIndex) {
+			const index = /* @__PURE__ */ new Map();
+			for (const c of this.controllersOverview) {
+				let byMethod = index.get(c.type);
+				if (!byMethod) {
+					byMethod = /* @__PURE__ */ new Map();
+					index.set(c.type, byMethod);
+				}
+				for (const h of c.handlers) {
+					const list = byMethod.get(h.method);
+					if (list) list.push(h);
+					else byMethod.set(h.method, [h]);
+				}
+			}
+			this.handlerOverviewIndex = index;
+		}
+		return this.handlerOverviewIndex;
+	}
+	/**
 	* ### init
 	* Ititializes adapter. Must be called after adapters are attached.
 	*/ async init() {
@@ -1451,8 +1575,26 @@ function _define_property(obj, key, value) {
 		}
 		this.unregisteredControllers.unshift(this);
 		await this.bindControllers();
+		await this.runInitHooks();
 		for (const a of this.adapters) await (a.onInit && a.onInit(this));
 	}
+	/**
+	* Runs every `@MoostInit`-decorated controller method exactly once, after all
+	* controllers are bound (complete `getControllersOverview()`) and before the
+	* `adapter.onInit` loop. Hooks run in ascending `priority`, then registration
+	* order. Each runs on its controller's SINGLETON instance inside a synthetic
+	* init context (no interceptors; params resolve via the RESOLVE pipe only).
+	* A throwing hook rejects `init()` (fail-fast).
+	*/ async runInitHooks() {
+		if (this.initHooks.length === 0) return;
+		const hooks = this.initHooks.toSorted((a, b) => a.priority - b.priority);
+		for (const hook of hooks) await createEventContext$1({ logger: this.logger }, async () => {
+			const instance = await hook.getInstance();
+			setControllerContext(instance, hook.method, "", { prefix: hook.computedPrefix });
+			const args = hook.resolveArgs ? await hook.resolveArgs() : [];
+			await instance[hook.method](...args);
+		});
+	}
 	async bindControllers() {
 		const thisMeta = getMoostMate().read(this);
 		const provide = {
@@ -1507,8 +1649,10 @@ function _define_property(obj, key, value) {
 			provide: classMeta?.provide,
 			replace: classMeta?.replace,
 			logger: this.logger,
-			moostInstance: this
+			moostInstance: this,
+			registerInitHook: (hook) => this.initHooks.push(hook)
 		}));
+		this.handlerOverviewIndex = void 0;
 		if (classMeta?.importController) {
 			const prefix = typeof replaceOwnPrefix === "string" ? replaceOwnPrefix : classMeta.controller?.prefix;
 			const mergedProvide = {
@@ -1608,7 +1752,7 @@ function _define_property(obj, key, value) {
 		this.logger.info(`${prefix || ""}${c}${eventName} ${"\x1B[0m\x1B[2m\x1B[32m" + c}→ ${classConstructor.name}.${"\x1B[36m" + c}${method}()${coff}`);
 	}
 	constructor(options) {
-		super(), _define_property(this, "options", void 0), _define_property(this, "logger", void 0), _define_property(this, "pipes", void 0), _define_property(this, "interceptors", void 0), _define_property(this, "adapters", void 0), _define_property(this, "controllersOverview", void 0), _define_property(this, "provide", void 0), _define_property(this, "replace", void 0), _define_property(this, "unregisteredControllers", void 0), _define_property(this, "globalInterceptorHandler", void 0), this.options = options, this.pipes = Array.from(sharedPipes), this.interceptors = [], this.adapters = [], this.controllersOverview = [], this.provide = createProvideRegistry$1([Infact, getMoostInfact], [Mate, getMoostMate]), this.replace = {}, this.unregisteredControllers = [];
+		super(), _define_property(this, "options", void 0), _define_property(this, "logger", void 0), _define_property(this, "pipes", void 0), _define_property(this, "interceptors", void 0), _define_property(this, "adapters", void 0), _define_property(this, "controllersOverview", void 0), _define_property(this, "handlerOverviewIndex", void 0), _define_property(this, "initHooks", void 0), _define_property(this, "provide", void 0), _define_property(this, "replace", void 0), _define_property(this, "unregisteredControllers", void 0), _define_property(this, "globalInterceptorHandler", void 0), this.options = options, this.pipes = Array.from(sharedPipes), this.interceptors = [], this.adapters = [], this.controllersOverview = [], this.initHooks = [], this.provide = createProvideRegistry$1([Infact, getMoostInfact], [Mate, getMoostMate]), this.replace = {}, this.unregisteredControllers = [];
 		this.logger = options?.logger || getDefaultLogger(`moost`);
 		setDefaultLogger(this.logger);
 		const mate = getMoostMate();
@@ -1617,4 +1761,56 @@ function _define_property(obj, key, value) {
 };
 
 //#endregion
-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 };
+//#region packages/moost/src/decorators/resolve-moost.ts
+/**
+* Resolves the running {@link Moost} application instance from the current
+* controller context: returns the controller directly when it already IS the
+* Moost app (Moost registers itself as a controller), otherwise resolves it
+* through DI. Shared by `@InjectMoost` and `@InjectMoostLogger`.
+*/ async function resolveMoost() {
+	const { instantiate, getController } = useControllerContext();
+	const controller = getController();
+	return controller instanceof Moost ? controller : await instantiate(Moost);
+}
+
+//#endregion
+//#region packages/moost/src/handler-paths.ts
+/**
+* Returns every actual mounted path under which `controller.method` is registered,
+* read from the post-bind controllers overview. Accounts for multi-prefix mounts
+* (`@ImportController` at several places), multiple verbs on one method, and
+* multiple `registeredAs` entries. Returns **distinct** paths; empty array if none
+* match.
+*
+* Only meaningful after `Moost.init()` has bound controllers — typically called
+* from a `@MoostInit` method (see [MoostInit](./decorators/init.decorator.ts)).
+*
+* @param controller class constructor or instance whose method to look up
+* @param method controller method name (e.g. the one carrying `@Get('refresh')`)
+*/ function getHandlerPaths(moost, controller, method, opts) {
+	const ctor = isConstructor$1(controller) ? controller : getConstructor$1(controller);
+	const handlers = moost.getHandlerOverviewIndex().get(ctor)?.get(method);
+	if (!handlers) return [];
+	const { type, predicate } = opts ?? {};
+	const paths = /* @__PURE__ */ new Set();
+	for (const h of handlers) {
+		if (type && h.type !== type) continue;
+		if (predicate && !predicate(h)) continue;
+		for (const r of h.registeredAs) paths.add(r.path);
+	}
+	return [...paths];
+}
+/**
+* Composable form of {@link getHandlerPaths}. Resolves the running Moost app and
+* defaults the controller to the current one from context — designed for use
+* inside a `@MoostInit` method or an event handler. `method` defaults to the
+* current context method; pass it explicitly from `@MoostInit` to target a
+* handler method (the init method itself is not a handler).
+*/ async function useHandlerPaths(method, opts) {
+	const moost = await resolveMoost();
+	const { getController, getMethod } = useControllerContext();
+	return getHandlerPaths(moost, getController(), method ?? getMethod() ?? "", opts);
+}
+
+//#endregion
+export { After, ApplyDecorators, Before, Circular, Const, ConstFactory, ContextInjector, Controller, Description, HandlerPaths, Id, ImportController, Inherit, Inject, InjectEventLogger, InjectFromScope, InjectMoost, InjectMoostLogger, InjectScopeVars, Injectable, Intercept, Interceptor, InterceptorHandler, Label, LoggerTopic, Moost, MoostInit, 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, getHandlerPaths, getInfactScopeVars, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, globalKey, isConstructor, isThenable, key, loggerConsoleTransport, mergeSorted, registerEventScope, replaceContextInjector, resetContextInjector, resolvePipe, run, setControllerContext, setInfactLoggingOptions, setInterceptResult, setOvertake, useControllerContext, useHandlerPaths, useInterceptResult, useLogger, useOvertake, useScopeId };