moost 0.6.18 → 0.6.21

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as _wooksjs_event_core from '@wooksjs/event-core';
-import { EventContext, Logger } from '@wooksjs/event-core';
+import { EventContext, Logger, Key } from '@wooksjs/event-core';
 export { Cached, ContextInjector, EventContext, EventContextOptions, Key, Logger, cached, createEventContext, current, eventTypeKey, getContextInjector, key, replaceContextInjector, resetContextInjector, run, useLogger } from '@wooksjs/event-core';
-import { TProvideRegistry, Infact, TReplaceRegistry, TProvideFn } from '@prostojs/infact';
+import { TProvideRegistry, TReplaceRegistry, Infact, TProvideFn } from '@prostojs/infact';
 export { TProvideRegistry, createProvideRegistry, createReplaceRegistry } from '@prostojs/infact';
 import * as _prostojs_mate from '@prostojs/mate';
 import { TMateParamMeta, Mate } from '@prostojs/mate';
@@ -131,13 +131,46 @@ declare function ImportController(controller: TFunction | TObject, provide?: TPr
  */
 declare function ImportController(prefix: string, controller: TFunction | TObject, provide?: TProvideRegistry): ClassDecorator;
 
-/**
- * ## Inherit
- * ### @Decorator
- * Inherit metadata from super class
- * @returns
- */
-declare const Inherit: () => MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+type TDecoratorLevel = 'CLASS' | 'METHOD' | 'PROP' | 'PARAM';
+
+/** Metadata context passed to pipe functions during argument/property resolution. */
+interface TPipeMetas<T extends TObject = TEmpty> {
+    classMeta?: TMoostMetadata & T;
+    methodMeta?: TMoostMetadata & T;
+    propMeta?: TMoostMetadata & T;
+    paramMeta?: TMoostParamsMetadata & T;
+    targetMeta?: TMoostParamsMetadata & T;
+    instance?: TObject;
+    scopeId?: string | symbol;
+    type: TFunction;
+    index?: number;
+    key: string | symbol;
+    instantiate: <T extends TObject>(t: TClassConstructor<T>) => Promise<T>;
+}
+/** A pipe function that transforms, resolves, or validates a value during the pipe pipeline. */
+interface TPipeFn<T extends TObject = TEmpty> {
+    (value: unknown, metas: TPipeMetas<T>, level: TDecoratorLevel): unknown | Promise<unknown>;
+    priority?: TPipePriority;
+}
+/** Execution priority for pipes. Lower values run first. */
+declare enum TPipePriority {
+    BEFORE_RESOLVE = 0,
+    RESOLVE = 1,
+    AFTER_RESOLVE = 2,
+    BEFORE_TRANSFORM = 3,
+    TRANSFORM = 4,
+    AFTER_TRANSFORM = 5,
+    BEFORE_VALIDATE = 6,
+    VALIDATE = 7,
+    AFTER_VALIDATE = 8
+}
+/** A pipe entry pairing a handler function with its execution priority. */
+interface TPipeData {
+    handler: TPipeFn;
+    priority: TPipePriority;
+}
+
+declare const resolvePipe: TPipeFn<TEmpty>;
 
 type TInterceptorBeforeFn = (reply: (response: TAny) => void) => void | Promise<void>;
 type TInterceptorAfterFn = (response: TAny, reply: (response: TAny) => void) => void | Promise<void>;
@@ -188,7 +221,81 @@ declare enum TInterceptorPriority {
  */
 declare function Intercept(handler: TClassConstructor | TInterceptorDef, priority?: TInterceptorPriority, name?: string): ClassDecorator & MethodDecorator;
 
-type TDecoratorLevel = 'CLASS' | 'METHOD' | 'PROP' | 'PARAM';
+/** Core metadata shape attached to classes, methods, and properties by Moost decorators. */
+interface TMoostMetadata<H extends TObject = TEmpty> extends TCommonMetaFields, TCommonMoostMeta {
+    requiredProps?: (string | symbol)[];
+    controller?: {
+        prefix?: string;
+    };
+    importController?: {
+        prefix?: string;
+        typeResolver?: TClassConstructor | (() => TClassConstructor | TObject | Promise<TClassConstructor | TObject>);
+        provide?: TProvideRegistry;
+    }[];
+    properties?: (string | symbol)[];
+    injectable?: true | TInjectableScope;
+    interceptor?: {
+        priority: TInterceptorPriority;
+    };
+    interceptorHook?: 'before' | 'after' | 'error';
+    interceptors?: TInterceptorData[];
+    handlers?: TMoostHandler<H>[];
+    returnType?: TFunction;
+    provide?: TProvideRegistry;
+    replace?: TReplaceRegistry;
+    loggerTopic?: string;
+    /**
+     * Set by `@MoostInit()` — marks a method to run once after all controllers
+     * are bound and before adapters start serving. `priority` orders hooks
+     * (ascending) across all controllers.
+     */
+    moostInit?: {
+        priority: number;
+    };
+    params: (TMateParamMeta & TMoostParamsMetadata)[];
+}
+/** Metadata attached to constructor/method parameters by Moost decorators. */
+interface TMoostParamsMetadata extends TCommonMetaFields, TCommonMoostMeta {
+    circular?: () => TAny;
+    inject?: string | symbol | TClassConstructor;
+    nullable?: boolean;
+    paramSource?: string;
+    paramName?: string;
+    fromScope?: string | symbol;
+}
+/** DI scope for injectable classes: per-event or application-wide singleton. */
+type TInjectableScope = 'FOR_EVENT' | 'SINGLETON';
+/** Describes a registered handler (HTTP route, CLI command, workflow step, etc.). */
+type TMoostHandler<T> = {
+    type: string;
+    path?: string;
+} & T;
+/** Stored interceptor entry attached to a class or method via `@Intercept`. */
+interface TInterceptorData {
+    handler: TClassConstructor | TInterceptorDef;
+    priority: TInterceptorPriority;
+    name: string;
+}
+/** Returns the shared `Mate` instance operating in the `'moost'` metadata workspace. */
+declare function getMoostMate<Class extends TObject = TEmpty, Prop extends TObject = TEmpty, Param extends TObject = TEmpty>(): Mate<TMoostMetadata & Class & {
+    params: (Param & TMateParamMeta)[];
+}, TMoostMetadata & Prop & {
+    params: (Param & TMateParamMeta)[];
+}>;
+interface TCommonMetaFields {
+    id?: string;
+    label?: string;
+    value?: unknown;
+    description?: string;
+    optional?: boolean;
+    required?: boolean;
+}
+interface TCommonMoostMeta {
+    inherit?: boolean;
+    pipes?: TPipeData[];
+    resolver?: (metas: TPipeMetas<TAny>, level: TDecoratorLevel) => unknown;
+    type?: TFunction;
+}
 
 interface TInfactLoggingOptions {
     newInstance?: true | false | 'FOR_EVENT' | 'SINGLETON';
@@ -221,112 +328,303 @@ declare function getInfactScopeVars<T extends object>(name: string | symbol): T
  */
 declare function getNewMoostInfact(): Infact<TMoostMetadata<TEmpty>, TMoostMetadata<TEmpty>, TMoostParamsMetadata, TCustom>;
 
-/** Metadata context passed to pipe functions during argument/property resolution. */
-interface TPipeMetas<T extends TObject = TEmpty> {
-    classMeta?: TMoostMetadata & T;
-    methodMeta?: TMoostMetadata & T;
-    propMeta?: TMoostMetadata & T;
-    paramMeta?: TMoostParamsMetadata & T;
-    targetMeta?: TMoostParamsMetadata & T;
-    instance?: TObject;
-    scopeId?: string | symbol;
-    type: TFunction;
-    index?: number;
-    key: string | symbol;
-    instantiate: <T extends TObject>(t: TClassConstructor<T>) => Promise<T>;
-}
-/** A pipe function that transforms, resolves, or validates a value during the pipe pipeline. */
-interface TPipeFn<T extends TObject = TEmpty> {
-    (value: unknown, metas: TPipeMetas<T>, level: TDecoratorLevel): unknown | Promise<unknown>;
-    priority?: TPipePriority;
+/**
+ * A `@MoostInit`-decorated controller method, collected at bind time and run
+ * once by `Moost.init()` after all controllers are bound. Interceptors are not
+ * applied; params resolve through the RESOLVE pipe only.
+ */
+interface TInitHook {
+    priority: number;
+    method: string;
+    computedPrefix: string;
+    getInstance: () => Promise<TObject> | TObject;
+    resolveArgs?: () => unknown[] | Promise<unknown[]>;
 }
-/** Execution priority for pipes. Lower values run first. */
-declare enum TPipePriority {
-    BEFORE_RESOLVE = 0,
-    RESOLVE = 1,
-    AFTER_RESOLVE = 2,
-    BEFORE_TRANSFORM = 3,
-    TRANSFORM = 4,
-    AFTER_TRANSFORM = 5,
-    BEFORE_VALIDATE = 6,
-    VALIDATE = 7,
-    AFTER_VALIDATE = 8
+
+/** Summary of a registered controller, its metadata, prefix, and handlers. */
+interface TControllerOverview {
+    meta: TMoostMetadata;
+    computedPrefix: string;
+    type: TFunction;
+    handlers: THandlerOverview[];
 }
-/** A pipe entry pairing a handler function with its execution priority. */
-interface TPipeData {
-    handler: TPipeFn;
-    priority: TPipePriority;
+/** Summary of a registered handler method within a controller. */
+interface THandlerOverview {
+    meta: TMoostMetadata;
+    path?: string;
+    type: string;
+    method: string;
+    handler: TMoostHandler<TEmpty>;
+    registeredAs: {
+        path: string;
+        args: string[];
+    }[];
 }
+/** Hook points in the event handler lifecycle where context injectors are invoked. */
+type TContextInjectorHook = 'Event:start' | 'Interceptors:init' | 'Arguments:resolve' | 'Interceptors:before' | 'Handler' | 'Interceptors:after';
 
-declare const resolvePipe: TPipeFn<TEmpty>;
-
-/** Core metadata shape attached to classes, methods, and properties by Moost decorators. */
-interface TMoostMetadata<H extends TObject = TEmpty> extends TCommonMetaFields, TCommonMoostMeta {
-    requiredProps?: (string | symbol)[];
-    controller?: {
-        prefix?: string;
-    };
-    importController?: {
-        prefix?: string;
-        typeResolver?: TClassConstructor | (() => TClassConstructor | TObject | Promise<TClassConstructor | TObject>);
-        provide?: TProvideRegistry;
-    }[];
-    properties?: (string | symbol)[];
-    injectable?: true | TInjectableScope;
-    interceptor?: {
-        priority: TInterceptorPriority;
-    };
-    interceptorHook?: 'before' | 'after' | 'error';
-    interceptors?: TInterceptorData[];
-    handlers?: TMoostHandler<H>[];
-    returnType?: TFunction;
-    provide?: TProvideRegistry;
-    replace?: TReplaceRegistry;
-    loggerTopic?: string;
-    params: (TMateParamMeta & TMoostParamsMetadata)[];
+interface TMoostOptions {
+    /**
+     * Prefix that is used for each event path
+     */
+    globalPrefix?: string;
+    logger?: TConsoleBase;
 }
-/** Metadata attached to constructor/method parameters by Moost decorators. */
-interface TMoostParamsMetadata extends TCommonMetaFields, TCommonMoostMeta {
-    circular?: () => TAny;
-    inject?: string | symbol | TClassConstructor;
-    nullable?: boolean;
-    paramSource?: string;
-    paramName?: string;
-    fromScope?: string | symbol;
+/**
+ * ## Moost
+ * Main moostjs class that serves as a shell for Moost Adapters
+ *
+ * ### Usage with HTTP Adapter
+ * ```ts
+ * │  // HTTP server example
+ * │  import { MoostHttp, Get } from '@moostjs/event-http'
+ * │  import { Moost, Param } from 'moost'
+ * │
+ * │  class MyServer extends Moost {
+ * │      @Get('test/:name')
+ * │      test(@Param('name') name: string) {
+ * │          return { message: `Hello ${name}!` }
+ * │      }
+ * │  }
+ * │
+ * │  const app = new MyServer()
+ * │  const http = new MoostHttp()
+ * │  app.adapter(http).listen(3000, () => {
+ * │      app.getLogger('MyApp').log('Up on port 3000')
+ * │  })
+ * │  app.init()
+ * ```
+ * ### Usage with CLI Adapter
+ * ```ts
+ * │  // CLI example
+ * │  import { MoostCli, Cli, CliOption, cliHelpInterceptor } from '@moostjs/event-cli'
+ * │  import { Moost, Param } from 'moost'
+ * │
+ * │  class MyApp extends Moost {
+ * │      @Cli('command/:arg')
+ * │      command(
+ * │         @Param('arg')
+ * │         arg: string,
+ * │         @CliOption('test', 't')
+ * │         test: boolean,
+ * │      ) {
+ * │          return `command run with flag arg=${ arg }, test=${ test }`
+ * │      }
+ * │  }
+ * │
+ * │  const app = new MyApp()
+ * │  app.applyGlobalInterceptors(cliHelpInterceptor())
+ * │
+ * │  const cli = new MoostCli()
+ * │  app.adapter(cli)
+ * │  app.init()
+ * ```
+ */
+declare class Moost extends Hookable {
+    protected options?: TMoostOptions | undefined;
+    protected logger: TConsoleBase;
+    protected pipes: TPipeData[];
+    protected interceptors: TInterceptorData[];
+    protected adapters: TMoostAdapter<TAny>[];
+    protected controllersOverview: TControllerOverview[];
+    protected handlerOverviewIndex?: Map<TFunction, Map<string, THandlerOverview[]>>;
+    protected initHooks: TInitHook[];
+    protected provide: TProvideRegistry;
+    protected replace: TReplaceRegistry;
+    protected unregisteredControllers: (TObject | TFunction | [string, TObject | TFunction])[];
+    constructor(options?: TMoostOptions | undefined);
+    _fireEventStart(source: TMoostAdapter<unknown>): void;
+    _fireEventEnd(source: TMoostAdapter<unknown>): void;
+    /**
+     * ### getLogger
+     * Provides application logger
+     * ```js
+     * // get logger with topic = "App"
+     * const logger = app.getLogger('App')
+     * logger.log('...')
+     * ```
+     * @param topic
+     * @returns
+     */
+    getLogger(topic?: string): TConsoleBase;
+    adapter<T extends TMoostAdapter<TAny>>(a: T): T;
+    getControllersOverview(): TControllerOverview[];
+    /**
+     * @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(): Map<TFunction, Map<string, THandlerOverview[]>>;
+    /**
+     * ### init
+     * Ititializes adapter. Must be called after adapters are attached.
+     */
+    init(): Promise<void>;
+    /**
+     * 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).
+     */
+    protected runInitHooks(): Promise<void>;
+    protected bindControllers(): Promise<void>;
+    protected bindController(controller: TFunction | TObject, provide: TProvideRegistry, replace: TReplaceRegistry, globalPrefix: string, replaceOwnPrefix?: string): Promise<void>;
+    applyGlobalPipes(...items: (TPipeFn | TPipeData)[]): this;
+    protected globalInterceptorHandler?: () => InterceptorHandler | undefined;
+    /**
+     * Provides InterceptorHandler with global interceptors and pipes.
+     * Used to process interceptors when event handler was not found.
+     *
+     * @returns IterceptorHandler
+     */
+    getGlobalInterceptorHandler(): InterceptorHandler | undefined;
+    applyGlobalInterceptors(...items: (TClassConstructor | TInterceptorDef | TInterceptorData)[]): this;
+    /**
+     * Register new entries to provide as dependency injections
+     * @param provide - Provide Registry (use createProvideRegistry from '\@prostojs/infact')
+     * @returns
+     */
+    setProvideRegistry(provide: TProvideRegistry): this;
+    /**
+     * Register replace classes to provide as dependency injections
+     * @param replace - Replace Registry (use createReplaceRegistry from '\@prostojs/infact')
+     * @returns
+     */
+    setReplaceRegistry(replace: TReplaceRegistry): this;
+    /**
+     * Register controllers (similar to @ImportController decorator)
+     * @param controllers - list of target controllers (instances)
+     * @returns
+     */
+    registerControllers(...controllers: (TObject | TFunction | [string, TObject | TFunction])[]): this;
+    logMappedHandler(eventName: string, classConstructor: Function, method: string, stroke?: boolean, prefix?: string): void;
 }
-/** DI scope for injectable classes: per-event or application-wide singleton. */
-type TInjectableScope = 'FOR_EVENT' | 'SINGLETON';
-/** Describes a registered handler (HTTP route, CLI command, workflow step, etc.). */
-type TMoostHandler<T> = {
-    type: string;
-    path?: string;
-} & T;
-/** Stored interceptor entry attached to a class or method via `@Intercept`. */
-interface TInterceptorData {
-    handler: TClassConstructor | TInterceptorDef;
-    priority: TInterceptorPriority;
-    name: string;
+interface TMoostAdapterOptions<H, T> {
+    prefix: string;
+    fakeInstance: T;
+    getInstance: () => Promise<T> | T;
+    method: keyof T;
+    handlers: TMoostHandler<H>[];
+    getIterceptorHandler: () => InterceptorHandler | undefined;
+    resolveArgs?: () => Promise<unknown[]> | unknown[];
+    controllerName?: string;
+    logHandler: (eventName: string) => void;
+    register: (handler: TMoostHandler<TEmpty>, path: string, args: string[]) => void;
 }
-/** Returns the shared `Mate` instance operating in the `'moost'` metadata workspace. */
-declare function getMoostMate<Class extends TObject = TEmpty, Prop extends TObject = TEmpty, Param extends TObject = TEmpty>(): Mate<TMoostMetadata & Class & {
-    params: (Param & TMateParamMeta)[];
-}, TMoostMetadata & Prop & {
-    params: (Param & TMateParamMeta)[];
-}>;
-interface TCommonMetaFields {
-    id?: string;
-    label?: string;
-    value?: unknown;
-    description?: string;
-    optional?: boolean;
-    required?: boolean;
+interface TMoostAdapter<H> {
+    name: string;
+    bindHandler: <T extends TObject = TObject>(options: TMoostAdapterOptions<H, T>) => void | Promise<void>;
+    onInit?: (moost: Moost) => void | Promise<void>;
+    getProvideRegistry?: () => TProvideRegistry;
 }
-interface TCommonMoostMeta {
-    inherit?: boolean;
-    pipes?: TPipeData[];
-    resolver?: (metas: TPipeMetas<TAny>, level: TDecoratorLevel) => unknown;
-    type?: TFunction;
+
+interface TGetHandlerPathsOptions {
+    /** Restrict to handlers of this event type, e.g. `'HTTP'`. */
+    type?: string;
+    /**
+     * Custom predicate to select handlers — keeps event-specific knowledge out of
+     * core, e.g. filter by HTTP verb: `(h) => (h.handler as { method: string }).method === 'GET'`.
+     */
+    predicate?: (handler: THandlerOverview) => boolean;
 }
+/**
+ * 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')`)
+ */
+declare function getHandlerPaths(moost: Moost, controller: TClassConstructor | TObject, method: string, opts?: TGetHandlerPathsOptions): string[];
+/**
+ * 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).
+ */
+declare function useHandlerPaths(method?: string, opts?: TGetHandlerPathsOptions): Promise<string[]>;
+
+/**
+ * ## 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}.
+ */
+declare function HandlerPaths(method?: string, opts?: TGetHandlerPathsOptions): ParameterDecorator & PropertyDecorator;
+
+/**
+ * ## Inherit
+ * ### @Decorator
+ * Inherit metadata from super class
+ * @returns
+ */
+declare const Inherit: () => MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
+
+/**
+ * ## 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)
+ * │    }
+ * │  }
+ * ```
+ */
+declare function MoostInit(opts?: {
+    priority?: number;
+}): MethodDecorator;
+/**
+ * ## 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.
+ */
+declare function InjectMoost(): ParameterDecorator & PropertyDecorator;
 
 /**
  * ## Injectable
@@ -609,168 +907,6 @@ declare function mergeSorted<T extends {
     priority: number;
 }>(...lists: (T[] | readonly T[] | undefined)[]): T[];
 
-/** Summary of a registered controller, its metadata, prefix, and handlers. */
-interface TControllerOverview {
-    meta: TMoostMetadata;
-    computedPrefix: string;
-    type: TFunction;
-    handlers: THandlerOverview[];
-}
-/** Summary of a registered handler method within a controller. */
-interface THandlerOverview {
-    meta: TMoostMetadata;
-    path?: string;
-    type: string;
-    method: string;
-    handler: TMoostHandler<TEmpty>;
-    registeredAs: {
-        path: string;
-        args: string[];
-    }[];
-}
-/** Hook points in the event handler lifecycle where context injectors are invoked. */
-type TContextInjectorHook = 'Event:start' | 'Interceptors:init' | 'Arguments:resolve' | 'Interceptors:before' | 'Handler' | 'Interceptors:after';
-
-interface TMoostOptions {
-    /**
-     * Prefix that is used for each event path
-     */
-    globalPrefix?: string;
-    logger?: TConsoleBase;
-}
-/**
- * ## Moost
- * Main moostjs class that serves as a shell for Moost Adapters
- *
- * ### Usage with HTTP Adapter
- * ```ts
- * │  // HTTP server example
- * │  import { MoostHttp, Get } from '@moostjs/event-http'
- * │  import { Moost, Param } from 'moost'
- * │
- * │  class MyServer extends Moost {
- * │      @Get('test/:name')
- * │      test(@Param('name') name: string) {
- * │          return { message: `Hello ${name}!` }
- * │      }
- * │  }
- * │
- * │  const app = new MyServer()
- * │  const http = new MoostHttp()
- * │  app.adapter(http).listen(3000, () => {
- * │      app.getLogger('MyApp').log('Up on port 3000')
- * │  })
- * │  app.init()
- * ```
- * ### Usage with CLI Adapter
- * ```ts
- * │  // CLI example
- * │  import { MoostCli, Cli, CliOption, cliHelpInterceptor } from '@moostjs/event-cli'
- * │  import { Moost, Param } from 'moost'
- * │
- * │  class MyApp extends Moost {
- * │      @Cli('command/:arg')
- * │      command(
- * │         @Param('arg')
- * │         arg: string,
- * │         @CliOption('test', 't')
- * │         test: boolean,
- * │      ) {
- * │          return `command run with flag arg=${ arg }, test=${ test }`
- * │      }
- * │  }
- * │
- * │  const app = new MyApp()
- * │  app.applyGlobalInterceptors(cliHelpInterceptor())
- * │
- * │  const cli = new MoostCli()
- * │  app.adapter(cli)
- * │  app.init()
- * ```
- */
-declare class Moost extends Hookable {
-    protected options?: TMoostOptions | undefined;
-    protected logger: TConsoleBase;
-    protected pipes: TPipeData[];
-    protected interceptors: TInterceptorData[];
-    protected adapters: TMoostAdapter<TAny>[];
-    protected controllersOverview: TControllerOverview[];
-    protected provide: TProvideRegistry;
-    protected replace: TReplaceRegistry;
-    protected unregisteredControllers: (TObject | TFunction | [string, TObject | TFunction])[];
-    constructor(options?: TMoostOptions | undefined);
-    _fireEventStart(source: TMoostAdapter<unknown>): void;
-    _fireEventEnd(source: TMoostAdapter<unknown>): void;
-    /**
-     * ### getLogger
-     * Provides application logger
-     * ```js
-     * // get logger with topic = "App"
-     * const logger = app.getLogger('App')
-     * logger.log('...')
-     * ```
-     * @param topic
-     * @returns
-     */
-    getLogger(topic?: string): TConsoleBase;
-    adapter<T extends TMoostAdapter<TAny>>(a: T): T;
-    getControllersOverview(): TControllerOverview[];
-    /**
-     * ### init
-     * Ititializes adapter. Must be called after adapters are attached.
-     */
-    init(): Promise<void>;
-    protected bindControllers(): Promise<void>;
-    protected bindController(controller: TFunction | TObject, provide: TProvideRegistry, replace: TReplaceRegistry, globalPrefix: string, replaceOwnPrefix?: string): Promise<void>;
-    applyGlobalPipes(...items: (TPipeFn | TPipeData)[]): this;
-    protected globalInterceptorHandler?: () => InterceptorHandler | undefined;
-    /**
-     * Provides InterceptorHandler with global interceptors and pipes.
-     * Used to process interceptors when event handler was not found.
-     *
-     * @returns IterceptorHandler
-     */
-    getGlobalInterceptorHandler(): InterceptorHandler | undefined;
-    applyGlobalInterceptors(...items: (TClassConstructor | TInterceptorDef | TInterceptorData)[]): this;
-    /**
-     * Register new entries to provide as dependency injections
-     * @param provide - Provide Registry (use createProvideRegistry from '\@prostojs/infact')
-     * @returns
-     */
-    setProvideRegistry(provide: TProvideRegistry): this;
-    /**
-     * Register replace classes to provide as dependency injections
-     * @param replace - Replace Registry (use createReplaceRegistry from '\@prostojs/infact')
-     * @returns
-     */
-    setReplaceRegistry(replace: TReplaceRegistry): this;
-    /**
-     * Register controllers (similar to @ImportController decorator)
-     * @param controllers - list of target controllers (instances)
-     * @returns
-     */
-    registerControllers(...controllers: (TObject | TFunction | [string, TObject | TFunction])[]): this;
-    logMappedHandler(eventName: string, classConstructor: Function, method: string, stroke?: boolean, prefix?: string): void;
-}
-interface TMoostAdapterOptions<H, T> {
-    prefix: string;
-    fakeInstance: T;
-    getInstance: () => Promise<T> | T;
-    method: keyof T;
-    handlers: TMoostHandler<H>[];
-    getIterceptorHandler: () => InterceptorHandler | undefined;
-    resolveArgs?: () => Promise<unknown[]> | unknown[];
-    controllerName?: string;
-    logHandler: (eventName: string) => void;
-    register: (handler: TMoostHandler<TEmpty>, path: string, args: string[]) => void;
-}
-interface TMoostAdapter<H> {
-    name: string;
-    bindHandler: <T extends TObject = TObject>(options: TMoostAdapterOptions<H, T>) => void | Promise<void>;
-    onInit?: (moost: Moost) => void | Promise<void>;
-    getProvideRegistry?: () => TProvideRegistry;
-}
-
 /**
  * Sets the controller context for the current event scope.
  * Called internally by adapters when dispatching events to handlers.
@@ -811,6 +947,15 @@ declare function useControllerContext<T extends object>(ctx?: EventContext): {
     } & _prostojs_mate.TMateClassMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & object> & _prostojs_mate.TMatePropMeta<_prostojs_mate.TMateParamMeta & TMoostParamsMetadata & object>) | undefined;
 };
 
+/**
+ * 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.
+ */
+declare function globalKey<T>(name: string): Key<T>;
+
 /**
  * Define a before-phase interceptor.
  *
@@ -889,5 +1034,5 @@ declare function createLogger(opts?: Partial<TProstoLoggerOptions>): ProstoLogge
 /** Default colored console transport used by Moost loggers. */
 declare const loggerConsoleTransport: _prostojs_logger.TProstoLoggerTransportFn<any>;
 
-export { After, ApplyDecorators, Before, Circular, Const, ConstFactory, Controller, Description, Id, ImportController, Inherit, Inject, InjectEventLogger, InjectFromScope, InjectMoostLogger, InjectScopeVars, Injectable, Intercept, Interceptor, InterceptorHandler, Label, LoggerTopic, Moost, OnError, Optional, Overtake, Param, Params, Pipe, Provide, Replace, Required, Resolve, Response, TInterceptorPriority, TPipePriority, Value, createLogger, defineAfterInterceptor, defineBeforeInterceptor, defineErrorInterceptor, defineInfactScope, defineInterceptor, defineMoostEventHandler, definePipeFn, getInfactScopeVars, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, isThenable, loggerConsoleTransport, mergeSorted, registerEventScope, resolvePipe, setControllerContext, setInfactLoggingOptions, setInterceptResult, setOvertake, useControllerContext, useInterceptResult, useOvertake, useScopeId };
-export type { TAny, TAnyFn, TClassConstructor, TContextInjectorHook, TControllerOverview, TEmpty, TFunction, TInjectableScope, TInterceptorAfterFn, TInterceptorBeforeFn, TInterceptorData, TInterceptorDef, TInterceptorDefFactory, TInterceptorEntry, TInterceptorErrorFn, TLogger, TMoostAdapter, TMoostAdapterOptions, TMoostEventHandlerHookOptions, TMoostEventHandlerOptions, TMoostHandler, TMoostMetadata, TMoostOptions, TMoostParamsMetadata, TObject, TOvertakeFn, TPipeData, TPipeFn, TPipeMetas, TPrimitives };
+export { After, ApplyDecorators, Before, Circular, Const, ConstFactory, 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, Provide, Replace, Required, Resolve, Response, TInterceptorPriority, TPipePriority, Value, createLogger, defineAfterInterceptor, defineBeforeInterceptor, defineErrorInterceptor, defineInfactScope, defineInterceptor, defineMoostEventHandler, definePipeFn, getHandlerPaths, getInfactScopeVars, getInstanceOwnMethods, getInstanceOwnProps, getMoostInfact, getMoostMate, getNewMoostInfact, globalKey, isThenable, loggerConsoleTransport, mergeSorted, registerEventScope, resolvePipe, setControllerContext, setInfactLoggingOptions, setInterceptResult, setOvertake, useControllerContext, useHandlerPaths, useInterceptResult, useOvertake, useScopeId };
+export type { TAny, TAnyFn, TClassConstructor, TContextInjectorHook, TControllerOverview, TEmpty, TFunction, TGetHandlerPathsOptions, TInjectableScope, TInterceptorAfterFn, TInterceptorBeforeFn, TInterceptorData, TInterceptorDef, TInterceptorDefFactory, TInterceptorEntry, TInterceptorErrorFn, TLogger, TMoostAdapter, TMoostAdapterOptions, TMoostEventHandlerHookOptions, TMoostEventHandlerOptions, TMoostHandler, TMoostMetadata, TMoostOptions, TMoostParamsMetadata, TObject, TOvertakeFn, TPipeData, TPipeFn, TPipeMetas, TPrimitives };