@fluojs/event-bus 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fluo contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.ko.md

@@ -0,0 +1,123 @@
+# @fluojs/event-bus
+
+<p><a href="./README.md"><kbd>English</kbd></a> <strong><kbd>한국어</kbd></strong></p>
+
+fluo를 위한 인프로세스(In-process) 이벤트 발행 및 구독 패키지입니다. 데코레이터 기반의 핸들러 탐색 기능을 제공하며, Redis Pub/Sub과 같은 외부 트랜스포트 어댑터를 통해 프로세스 간 통신을 지원합니다.
+
+## 목차
+
+- [설치](#설치)
+- [사용 시점](#사용-시점)
+- [빠른 시작](#빠른-시작)
+- [일반적인 패턴](#일반적인-패턴)
+- [공개 API 개요](#공개-api-개요)
+- [관련 패키지](#관련-패키지)
+- [예제 소스](#예제-소스)
+
+## 설치
+
+```bash
+npm install @fluojs/event-bus
+```
+
+## 사용 시점
+
+- 직접적인 서비스 호출 대신 이벤트를 통해 컴포넌트 간의 결합도를 낮추고 싶을 때.
+- 하나의 동작에 대해 시스템의 여러 부분에서 반응해야 할 때 (예: 사용자 가입 시 환영 이메일 발송과 대시보드 업데이트를 동시에 수행).
+- 분산 환경 지원이 선택적으로 필요한 간단한 인메모리 이벤트 버스가 필요할 때.
+
+## 빠른 시작
+
+### 1. 이벤트 및 핸들러 정의
+
+이벤트 클래스를 정의하고, 핸들러 메서드에 `@OnEvent` 데코레이터를 사용합니다.
+
+```typescript
+import { OnEvent } from '@fluojs/event-bus';
+
+export class UserSignedUpEvent {
+  constructor(public readonly email: string) {}
+}
+
+export class NotificationService {
+  @OnEvent(UserSignedUpEvent)
+  async notify(event: UserSignedUpEvent) {
+    console.log(`환영 이메일 전송 대상: ${event.email}`);
+  }
+}
+```
+
+### 2. 모듈 등록 및 이벤트 발행
+
+`EventBusModule`을 등록하고 `EventBusLifecycleService`를 주입받아 이벤트를 발행합니다.
+
+인프로세스 이벤트 버스 등록은 `EventBusModule.forRoot(...)`로 구성합니다.
+
+```typescript
+import { Module, Inject } from '@fluojs/core';
+import { EventBusModule, EventBusLifecycleService } from '@fluojs/event-bus';
+
+@Module({
+  imports: [EventBusModule.forRoot()],
+  providers: [NotificationService],
+})
+export class AppModule {}
+
+export class UserService {
+  @Inject(EventBusLifecycleService)
+  private readonly eventBus: EventBusLifecycleService;
+
+  async signUp(email: string) {
+    // 사용자 저장 로직...
+    await this.eventBus.publish(new UserSignedUpEvent(email));
+  }
+}
+```
+
+## 일반적인 패턴
+
+### 분산 팬아웃 (Redis)
+
+트랜스포트 어댑터를 연결하여 이벤트 버스를 다른 프로세스로 확장할 수 있습니다.
+
+```typescript
+import { RedisEventBusTransport } from '@fluojs/event-bus/redis';
+
+EventBusModule.forRoot({
+  transport: new RedisEventBusTransport({ 
+    publishClient: redis, 
+    subscribeClient: redisSubscriber 
+  }),
+})
+```
+
+### 버전이 명시된 이벤트 키
+
+`static eventKey`를 사용하여 클래스 이름 변경이나 코드 압축(minification)과 관계없이 안정적인 채널 이름을 유지할 수 있습니다.
+
+```typescript
+class UserRegisteredEvent {
+  static readonly eventKey = 'user.registered.v1';
+}
+```
+
+## 공개 API 개요
+
+### 핵심 구성 요소
+- `EventBusModule`: 이벤트 버스 기능을 위한 기본 모듈입니다.
+- `EventBusLifecycleService`: 이벤트를 발행(`publish(event)`)하기 위한 기본 서비스입니다.
+- `@OnEvent(EventClass)`: 특정 메서드를 이벤트 핸들러로 지정하는 데코레이터입니다.
+- `EventBusModule.forRoot(...)`: in-process 이벤트 버스 구성을 설정합니다.
+
+### 인터페이스
+- `EventBusTransport`: 외부 트랜스포트 어댑터 구현을 위한 계약입니다.
+
+## 관련 패키지
+
+- `@fluojs/cqrs`: 더 정형화된 아키텍처 패턴을 위해 이벤트 버스 위에 구축된 패키지입니다.
+- `@fluojs/redis`: `RedisEventBusTransport` 사용 시 필요한 클라이언트를 제공합니다.
+
+## 예제 소스
+
+- `packages/event-bus/src/module.test.ts`: 핸들러 탐색 및 발행/구독 테스트 예제.
+- `packages/event-bus/src/public-surface.test.ts`: 공개 API 계약 검증 예제.

package/README.md

@@ -0,0 +1,122 @@
+# @fluojs/event-bus
+
+<p><strong><kbd>English</kbd></strong> <a href="./README.ko.md"><kbd>한국어</kbd></a></p>
+
+In-process event publishing and subscription for fluo. It features decorator-based handler discovery and support for external transport adapters like Redis Pub/Sub for cross-process communication.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [When to use](#when-to-use)
+- [Quick Start](#quick-start)
+- [Common Patterns](#common-patterns)
+- [Public API](#public-api)
+- [Related Packages](#related-packages)
+- [Example Sources](#example-sources)
+
+## Installation
+
+```bash
+npm install @fluojs/event-bus
+```
+
+## When to Use
+
+- When you need to decouple components by communicating via events instead of direct service calls.
+- When multiple parts of the system need to react to a single action (e.g., sending an email and updating a dashboard when a user registers).
+- When you need a simple in-memory event bus with optional support for distributed systems.
+
+## Quick Start
+
+### 1. Define an Event and Handler
+
+Create an event class and a handler method decorated with `@OnEvent`.
+
+```typescript
+import { OnEvent } from '@fluojs/event-bus';
+
+export class UserSignedUpEvent {
+  constructor(public readonly email: string) {}
+}
+
+export class NotificationService {
+  @OnEvent(UserSignedUpEvent)
+  async notify(event: UserSignedUpEvent) {
+    console.log(`Sending welcome email to: ${event.email}`);
+  }
+}
+```
+
+### 2. Register and Publish
+
+Import `EventBusModule` and inject `EventBusLifecycleService` to publish events.
+
+Use `EventBusModule.forRoot(...)` to wire the in-process event bus.
+
+```typescript
+import { Module, Inject } from '@fluojs/core';
+import { EventBusModule, EventBusLifecycleService } from '@fluojs/event-bus';
+
+@Module({
+  imports: [EventBusModule.forRoot()],
+  providers: [NotificationService],
+})
+export class AppModule {}
+
+export class UserService {
+  @Inject(EventBusLifecycleService)
+  private readonly eventBus: EventBusLifecycleService;
+
+  async signUp(email: string) {
+    // Logic to save user...
+    await this.eventBus.publish(new UserSignedUpEvent(email));
+  }
+}
+```
+
+## Common Patterns
+
+### Distributed Fan-out (Redis)
+
+Extend the event bus to other processes by plugging in a transport adapter.
+
+```typescript
+import { RedisEventBusTransport } from '@fluojs/event-bus/redis';
+
+EventBusModule.forRoot({
+  transport: new RedisEventBusTransport({ 
+    publishClient: redis, 
+    subscribeClient: redisSubscriber 
+  }),
+})
+```
+
+### Versioned Event Keys
+
+Use static `eventKey` to ensure stable channel names regardless of class minification or renames.
+
+```typescript
+class UserRegisteredEvent {
+  static readonly eventKey = 'user.registered.v1';
+}
+```
+
+## Public API Overview
+
+### Core
+- `EventBusModule`: Main entry point for event bus registration.
+- `EventBusLifecycleService`: Primary service for publishing events (`publish(event)`).
+- `@OnEvent(EventClass)`: Decorator to mark a method as an event handler.
+
+### Interfaces
+- `EventBusTransport`: Contract for implementing external transport adapters.
+
+## Related Packages
+
+- `@fluojs/cqrs`: Built on top of the event bus for more formal architectural patterns.
+- `@fluojs/redis`: Provides the clients required for `RedisEventBusTransport`.
+
+## Example Sources
+
+- `packages/event-bus/src/module.test.ts`: Handler discovery and publish/subscribe tests.
+- `packages/event-bus/src/public-surface.test.ts`: Public API contract verification.

package/dist/decorators.d.ts

@@ -0,0 +1,28 @@
+import type { EventType } from './types.js';
+type StandardMethodDecoratorFn = (value: Function, context: ClassMethodDecoratorContext) => void;
+type MethodDecoratorLike = StandardMethodDecoratorFn;
+/**
+ * Marks a public instance method as the handler for one event type.
+ *
+ * @param eventType Event constructor that should trigger the decorated method.
+ * @returns A method decorator that stores handler metadata for bootstrap discovery.
+ *
+ * @example
+ * ```ts
+ * import { OnEvent } from '@fluojs/event-bus';
+ *
+ * class UserRegisteredEvent {
+ *   constructor(public readonly email: string) {}
+ * }
+ *
+ * export class NotificationService {
+ *   @OnEvent(UserRegisteredEvent)
+ *   async notify(event: UserRegisteredEvent) {
+ *     await mailer.send(event.email);
+ *   }
+ * }
+ * ```
+ */
+export declare function OnEvent(eventType: EventType): MethodDecoratorLike;
+export {};
+//# sourceMappingURL=decorators.d.ts.map

package/dist/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAwB,SAAS,EAAE,MAAM,YAAY,CAAC;AAIlE,KAAK,yBAAyB,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,2BAA2B,KAAK,IAAI,CAAC;AACjG,KAAK,mBAAmB,GAAG,yBAAyB,CAAC;AAqBrD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,OAAO,CAAC,SAAS,EAAE,SAAS,GAAG,mBAAmB,CAkBjE"}

package/dist/decorators.js

@@ -0,0 +1,53 @@
+import { metadataSymbol } from '@fluojs/core/internal';
+import { eventBusMetadataSymbol } from './metadata.js';
+function getStandardMetadataBag(metadata) {
+  void metadataSymbol;
+  return metadata;
+}
+function defineStandardEventHandlerMetadata(metadata, propertyKey, eventHandlerMetadata) {
+  const bag = getStandardMetadataBag(metadata);
+  const current = bag[eventBusMetadataSymbol];
+  const map = current ?? new Map();
+  map.set(propertyKey, {
+    eventType: eventHandlerMetadata.eventType
+  });
+  bag[eventBusMetadataSymbol] = map;
+}
+
+/**
+ * Marks a public instance method as the handler for one event type.
+ *
+ * @param eventType Event constructor that should trigger the decorated method.
+ * @returns A method decorator that stores handler metadata for bootstrap discovery.
+ *
+ * @example
+ * ```ts
+ * import { OnEvent } from '@fluojs/event-bus';
+ *
+ * class UserRegisteredEvent {
+ *   constructor(public readonly email: string) {}
+ * }
+ *
+ * export class NotificationService {
+ *   @OnEvent(UserRegisteredEvent)
+ *   async notify(event: UserRegisteredEvent) {
+ *     await mailer.send(event.email);
+ *   }
+ * }
+ * ```
+ */
+export function OnEvent(eventType) {
+  const decorator = (_value, context) => {
+    if (context.private) {
+      throw new Error('@OnEvent() cannot be used on private methods.');
+    }
+    if (context.static) {
+      throw new Error('@OnEvent() cannot be used on static methods.');
+    }
+    const metadata = {
+      eventType
+    };
+    defineStandardEventHandlerMetadata(context.metadata, context.name, metadata);
+  };
+  return decorator;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { OnEvent } from './decorators.js';
+export { EventBusModule } from './module.js';
+export { EventBusLifecycleService } from './service.js';
+export * from './status.js';
+export { EVENT_BUS } from './tokens.js';
+export type { EventBus, EventBusModuleOptions, EventBusTransport, EventPublishOptions, EventType } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AACxD,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,QAAQ,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { OnEvent } from './decorators.js';
+export { EventBusModule } from './module.js';
+export { EventBusLifecycleService } from './service.js';
+export * from './status.js';
+export { EVENT_BUS } from './tokens.js';

package/dist/metadata.d.ts

@@ -0,0 +1,10 @@
+import { type MetadataPropertyKey } from '@fluojs/core';
+import type { EventHandlerMetadata } from './types.js';
+export declare function defineEventHandlerMetadata(target: object, propertyKey: MetadataPropertyKey, metadata: EventHandlerMetadata): void;
+export declare function getEventHandlerMetadata(target: object, propertyKey: MetadataPropertyKey): EventHandlerMetadata | undefined;
+export declare function getEventHandlerMetadataEntries(target: object): Array<{
+    metadata: EventHandlerMetadata;
+    propertyKey: MetadataPropertyKey;
+}>;
+export declare const eventBusMetadataSymbol: symbol;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../src/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAGxD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAsCvD,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,mBAAmB,EAChC,QAAQ,EAAE,oBAAoB,GAC7B,IAAI,CAEN;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,mBAAmB,GAAG,oBAAoB,GAAG,SAAS,CAS1H;AAED,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,MAAM,GACb,KAAK,CAAC;IAAE,QAAQ,EAAE,oBAAoB,CAAC;IAAC,WAAW,EAAE,mBAAmB,CAAA;CAAE,CAAC,CAW7E;AAED,eAAO,MAAM,sBAAsB,QAAkC,CAAC"}

package/dist/metadata.js

@@ -0,0 +1,45 @@
+import { ensureSymbolMetadataPolyfill, metadataSymbol } from '@fluojs/core/internal';
+void ensureSymbolMetadataPolyfill();
+const standardEventHandlerMetadataKey = Symbol.for('fluo.event-bus.standard.handler');
+const eventHandlerMetadataStore = new WeakMap();
+function cloneEventHandlerMetadata(metadata) {
+  return {
+    eventType: metadata.eventType
+  };
+}
+function getStandardMetadataBag(target) {
+  return target[metadataSymbol];
+}
+function getStandardEventHandlerMap(target) {
+  const constructor = target.constructor;
+  return constructor ? getStandardMetadataBag(constructor)?.[standardEventHandlerMetadataKey] : undefined;
+}
+function getOrCreateEventHandlerMap(target) {
+  let map = eventHandlerMetadataStore.get(target);
+  if (!map) {
+    map = new Map();
+    eventHandlerMetadataStore.set(target, map);
+  }
+  return map;
+}
+export function defineEventHandlerMetadata(target, propertyKey, metadata) {
+  getOrCreateEventHandlerMap(target).set(propertyKey, cloneEventHandlerMetadata(metadata));
+}
+export function getEventHandlerMetadata(target, propertyKey) {
+  const stored = eventHandlerMetadataStore.get(target)?.get(propertyKey);
+  const standard = getStandardEventHandlerMap(target)?.get(propertyKey);
+  if (!stored && !standard) {
+    return undefined;
+  }
+  return cloneEventHandlerMetadata(stored ?? standard);
+}
+export function getEventHandlerMetadataEntries(target) {
+  const stored = eventHandlerMetadataStore.get(target) ?? new Map();
+  const standard = getStandardEventHandlerMap(target) ?? new Map();
+  const keys = new Set([...stored.keys(), ...standard.keys()]);
+  return Array.from(keys).map(propertyKey => ({
+    metadata: getEventHandlerMetadata(target, propertyKey),
+    propertyKey
+  })).filter(entry => entry.metadata !== undefined);
+}
+export const eventBusMetadataSymbol = standardEventHandlerMetadataKey;

package/dist/module.d.ts

@@ -0,0 +1,15 @@
+import { type ModuleType } from '@fluojs/runtime';
+import type { EventBusModuleOptions } from './types.js';
+/**
+ * Runtime module entrypoint for the in-process event bus.
+ */
+export declare class EventBusModule {
+    /**
+     * Registers the event-bus providers as a global module.
+     *
+     * @param options Event bus module options for publish defaults and optional transport integration.
+     * @returns A module definition that exports `EventBusLifecycleService` and the compatibility token `EVENT_BUS`.
+     */
+    static forRoot(options?: EventBusModuleOptions): ModuleType;
+}
+//# sourceMappingURL=module.d.ts.map

package/dist/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAIhE,OAAO,KAAK,EAAE,qBAAqB,EAAuB,MAAM,YAAY,CAAC;AAoB7E;;GAEG;AACH,qBAAa,cAAc;IACzB;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,GAAE,qBAA0B,GAAG,UAAU;CAShE"}

package/dist/module.js

@@ -0,0 +1,35 @@
+import { defineModule } from '@fluojs/runtime';
+import { EventBusLifecycleService } from './service.js';
+import { EVENT_BUS, EVENT_BUS_OPTIONS } from './tokens.js';
+function createEventBusProviders(options = {}) {
+  return [{
+    provide: EVENT_BUS_OPTIONS,
+    useValue: options
+  }, EventBusLifecycleService, {
+    inject: [EventBusLifecycleService],
+    provide: EVENT_BUS,
+    useFactory: service => ({
+      publish: (event, publishOptions) => service.publish(event, publishOptions)
+    })
+  }];
+}
+
+/**
+ * Runtime module entrypoint for the in-process event bus.
+ */
+export class EventBusModule {
+  /**
+   * Registers the event-bus providers as a global module.
+   *
+   * @param options Event bus module options for publish defaults and optional transport integration.
+   * @returns A module definition that exports `EventBusLifecycleService` and the compatibility token `EVENT_BUS`.
+   */
+  static forRoot(options = {}) {
+    class EventBusModuleDefinition {}
+    return defineModule(EventBusModuleDefinition, {
+      exports: [EventBusLifecycleService, EVENT_BUS],
+      global: true,
+      providers: createEventBusProviders(options)
+    });
+  }
+}

package/dist/service.d.ts

@@ -0,0 +1,72 @@
+import type { Container } from '@fluojs/di';
+import { type ApplicationLogger, type CompiledModule, type OnApplicationBootstrap, type OnApplicationShutdown } from '@fluojs/runtime';
+import type { EventBus, EventBusModuleOptions, EventPublishOptions } from './types.js';
+/**
+ * Lifecycle-managed in-process event bus with optional external transport fan-out.
+ *
+ * The service discovers `@OnEvent()` handlers, clones payloads before dispatch,
+ * and can publish the same events to an external transport such as Redis Pub/Sub.
+ */
+export declare class EventBusLifecycleService implements EventBus, OnApplicationBootstrap, OnApplicationShutdown {
+    private readonly runtimeContainer;
+    private readonly compiledModules;
+    private readonly logger;
+    private readonly moduleOptions;
+    private descriptors;
+    private discoveryPromise;
+    private discovered;
+    private lifecycleState;
+    private readonly handlerInstances;
+    private readonly subscribedChannels;
+    private transportCloseFailures;
+    private transportPublishFailures;
+    private transportSubscribeFailures;
+    private readonly transport;
+    constructor(runtimeContainer: Container, compiledModules: readonly CompiledModule[], logger: ApplicationLogger, moduleOptions: EventBusModuleOptions);
+    onApplicationBootstrap(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+    /**
+     * Creates a platform status snapshot for health checks and diagnostics.
+     *
+     * @returns A structured snapshot describing discovery state, transport wiring, and failure counters.
+     */
+    createPlatformStatusSnapshot(): import("./status.js").EventBusPlatformStatusSnapshot;
+    /**
+     * Publishes one event to matching local handlers and, when configured, to the external transport.
+     *
+     * @param event Event instance to publish.
+     * @param options Optional timeout, abort signal, and wait-for-handler controls.
+     * @returns A promise that resolves once the configured local/transport publication completes.
+     */
+    publish(event: object, options?: EventPublishOptions): Promise<void>;
+    private matchEventDescriptors;
+    private createInvocationTasks;
+    private createBackgroundInvocationTasks;
+    private runInvocationTasksInBackground;
+    private invokeHandlerInBackground;
+    private ensureDiscovered;
+    private resolvePublishOptions;
+    private normalizeTimeoutMs;
+    private discoverHandlers;
+    private channelFromEventType;
+    private channelsForTransportPublish;
+    private publishToTransport;
+    private subscribeTransportChannels;
+    private subscribeTransportChannel;
+    private preloadHandlerInstances;
+    private invokeHandlerWithBounds;
+    private logPublishCancelledBeforeDispatch;
+    private logBoundedInvocationError;
+    private awaitInvocationBounds;
+    private createInvocationBounds;
+    private createTimeoutBound;
+    private createAbortBound;
+    private discoverHandlerDescriptors;
+    private shouldSkipNonSingletonCandidate;
+    private isDuplicateHandlerRegistration;
+    private createHandlerDescriptor;
+    private discoveryCandidates;
+    private invokeHandler;
+    private resolveHandlerInstance;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAY,MAAM,YAAY,CAAC;AACtD,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC3B,MAAM,iBAAiB,CAAC;AAMzB,OAAO,KAAK,EACV,QAAQ,EACR,qBAAqB,EAGrB,mBAAmB,EAEpB,MAAM,YAAY,CAAC;AA8DpB;;;;;GAKG;AACH,qBACa,wBAAyB,YAAW,QAAQ,EAAE,sBAAsB,EAAE,qBAAqB;IAapG,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAfhC,OAAO,CAAC,WAAW,CAAgC;IACnD,OAAO,CAAC,gBAAgB,CAA4B;IACpD,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,cAAc,CAAsF;IAC5G,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsC;IACvE,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAqB;IACxD,OAAO,CAAC,sBAAsB,CAAK;IACnC,OAAO,CAAC,wBAAwB,CAAK;IACrC,OAAO,CAAC,0BAA0B,CAAK;IACvC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgC;gBAGvC,gBAAgB,EAAE,SAAS,EAC3B,eAAe,EAAE,SAAS,cAAc,EAAE,EAC1C,MAAM,EAAE,iBAAiB,EACzB,aAAa,EAAE,qBAAqB;IAKjD,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;IAavC,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB5C;;;;OAIG;IACH,4BAA4B;IAa5B;;;;;;OAMG;IACG,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B1E,OAAO,CAAC,qBAAqB;IAI7B,OAAO,CAAC,qBAAqB;IAW7B,OAAO,CAAC,+BAA+B;IAWvC,OAAO,CAAC,8BAA8B;YAMxB,yBAAyB;YAazB,gBAAgB;IAqB9B,OAAO,CAAC,qBAAqB;IAY7B,OAAO,CAAC,kBAAkB;YAQZ,gBAAgB;IAW9B,OAAO,CAAC,oBAAoB;IAY5B,OAAO,CAAC,2BAA2B;YAcrB,kBAAkB;YAyBlB,0BAA0B;YAmB1B,yBAAyB;YAqCzB,uBAAuB;YAUvB,uBAAuB;IAmBrC,OAAO,CAAC,iCAAiC;IAOzC,OAAO,CAAC,yBAAyB;YAwBnB,qBAAqB;IAuBnC,OAAO,CAAC,sBAAsB;IAqB9B,OAAO,CAAC,kBAAkB;IAiB1B,OAAO,CAAC,gBAAgB;IAmBxB,OAAO,CAAC,0BAA0B;IAyBlC,OAAO,CAAC,+BAA+B;IAevC,OAAO,CAAC,8BAA8B;IA4BtC,OAAO,CAAC,uBAAuB;IAe/B,OAAO,CAAC,mBAAmB;YAsCb,aAAa;YA4Bb,sBAAsB;CAsBrC"}