@fluojs/event-bus 1.0.0 → 2.0.0

package/README.ko.md

@@ -52,7 +52,7 @@ export class NotificationService {
 
 `EventBusModule`을 등록하고 `EventBusLifecycleService`를 주입받아 이벤트를 발행합니다.
 
-인프로세스 이벤트 버스 등록은 `EventBusModule.forRoot(...)`로 구성합니다.
+인프로세스 이벤트 버스 등록은 `EventBusModule.forRoot(...)`로 구성합니다. Event-bus provider는 기본적으로 global(`global: true`)이므로 root graph를 import하는 모듈에서 `EventBusLifecycleService`와 `EVENT_BUS` 호환성 토큰을 사용할 수 있습니다. 모듈-local visibility가 필요하면 `EventBusModule.forRoot({ global: false })`를 전달하세요.
 
 ```typescript
 import { Module, Inject } from '@fluojs/core';
@@ -75,7 +75,9 @@ export class UserService {
 export class AppModule {}
 ```
 
-`publish(event, options?)`는 `signal`, `timeoutMs`, `waitForHandlers`를 지원합니다. `waitForHandlers`의 기본값은 `true`이며, 기다리는 로컬 핸들러와 기다리는 트랜스포트 publish는 동일한 timeout 및 cancellation bound를 공유합니다. `waitForHandlers`를 `false`로 설정하면 publish가 즉시 반환되고 timeout bound를 적용하지 않습니다. Shutdown 중에는 이벤트 버스가 진행 중인 awaited publish 및 inbound transport handler 작업을 drain한 뒤 트랜스포트를 닫고, lifecycle이 stopping에 진입한 뒤의 새 publish 호출과 shutdown 시작 뒤 도착한 inbound transport callback은 무시합니다. Shutdown drain은 기본값이 5000ms인 `EventBusModule.forRoot({ shutdown: { drainTimeoutMs } })`로 제한됩니다. 활성 dispatch 작업이 이 bound 이후에도 멈춰 있으면 bus는 degraded status diagnostic을 기록하고 경고를 남긴 뒤, 애플리케이션 close를 무기한 hang시키지 않고 transport cleanup을 계속합니다.
+`publish(event, options?)`는 `signal`, `timeoutMs`, `waitForHandlers`를 지원합니다. `waitForHandlers`의 기본값은 `true`이며, 기다리는 로컬 핸들러와 기다리는 트랜스포트 publish는 동일한 timeout 및 cancellation bound를 공유합니다. 이러한 bound가 실제 handler 또는 transport 작업이 끝나기 전에 호출자에게 반환되는 publish promise를 settle하더라도, shutdown은 해당 underlying awaited work가 settle되거나 shutdown drain bound가 만료될 때까지 계속 추적합니다. `waitForHandlers`를 `false`로 설정하면 publish가 즉시 반환되고 timeout bound를 적용하지 않지만, handler와 transport 작업은 background에서 계속 실행되며 shutdown drain 추적 대상에 남습니다. Shutdown 중에는 이벤트 버스가 진행 중인 awaited/background publish 및 inbound transport handler 작업을 drain한 뒤 트랜스포트를 닫고, lifecycle이 stopping에 진입한 뒤의 새 publish 호출과 shutdown 시작 뒤 도착한 inbound transport callback은 무시합니다. Shutdown drain은 기본값이 5000ms인 `EventBusModule.forRoot({ shutdown: { drainTimeoutMs } })`로 제한됩니다. 활성 dispatch 작업이 이 bound 이후에도 멈춰 있으면 bus는 degraded status diagnostic을 기록하고 경고를 남긴 뒤, 애플리케이션 close를 무기한 hang시키지 않고 transport cleanup을 계속합니다.
+
+**마이그레이션 참고:** `waitForHandlers: false`를 사용하는 애플리케이션은 이제 background handler 및 transport 작업을 위해 `app.close()`가 최대 `shutdown.drainTimeoutMs`까지 기다린 뒤 transport cleanup을 계속할 수 있음을 shutdown budget에 반영해야 합니다. 해당 작업을 bounded하게 유지하거나 애플리케이션에 적절한 drain budget을 구성하세요.
 
 ## 일반적인 패턴
 
@@ -94,6 +96,46 @@ EventBusModule.forRoot({
 })
 ```
 
+Redis Pub/Sub은 durable work queue가 아니라 fan-out transport입니다. 여러 애플리케이션 인스턴스가 같은 이벤트 채널을 구독하면 각 인스턴스가 같은 published fact를 볼 수 있습니다. 따라서 상태를 변경하거나 알림을 보내거나 외부 시스템을 호출하는 handler는 idempotent해야 합니다. Payload에 안정적인 event identifier 또는 business key를 담고, 이미 적용한 reaction을 기록하며, 반복 전달이 side effect를 두 번 실행하는 대신 같은 결과로 수렴하도록 만드세요.
+
+`@OnEvent(...)` handler는 작고 bounded하게 유지하세요. 빠른 local projection, cache invalidation, 가벼운 notification처럼 publish timeout과 shutdown drain window 안에 끝낼 수 있는 reaction에 적합합니다. Reaction이 느리거나, failure-prone이거나, retry 가능하거나, operator-visible dead-letter handling이 필요하다면 해당 작업을 inline으로 수행하지 말고 event handler에서 `@fluojs/queue`의 durable job으로 hand off하세요. Handoff에는 애플리케이션이 소유한 unique claim을 사용하고, `queue.enqueue(...)`가 성공한 뒤에만 handoff를 enqueued로 표시하세요. Enqueue가 실패하면 pending claim을 해제해 이후 duplicate event가 안전하게 다시 시도할 수 있게 합니다.
+
+아래 예제의 `this.reactions` helper는 `@fluojs/event-bus`나 `@fluojs/queue` API가 아니라 애플리케이션이 소유한 claim store를 나타냅니다. Business key를 atomic하게 claim하고 stale pending claim을 애플리케이션의 retry policy에 따라 복구할 수 있는 저장소로 구현하세요.
+
+```typescript
+import { Inject } from '@fluojs/core';
+import { OnEvent } from '@fluojs/event-bus';
+import { QueueLifecycleService } from '@fluojs/queue';
+
+export class GenerateInvoiceJob {
+  constructor(public readonly orderId: string) {}
+}
+
+@Inject(QueueLifecycleService)
+export class BillingEventsHandler {
+  constructor(private readonly queue: QueueLifecycleService) {}
+
+  @OnEvent(OrderPlacedEvent)
+  async enqueueInvoice(event: OrderPlacedEvent) {
+    const handoffKey = `${event.orderId}:invoice`;
+
+    if (!(await this.reactions.claimPending(handoffKey))) {
+      return;
+    }
+
+    try {
+      await this.queue.enqueue(new GenerateInvoiceJob(event.orderId));
+      await this.reactions.markEnqueued(handoffKey);
+    } catch (error) {
+      await this.reactions.releasePending(handoffKey);
+      throw error;
+    }
+  }
+}
+```
+
+비즈니스 사실이 발생했음을 표현할 때는 event bus를 사용하세요. Reaction에 retry, backoff, workload isolation, dead-letter inspection이 필요하면 Queue를 사용하세요. Claim이 pending인 동안 프로세스가 종료될 수 있다면 애플리케이션의 retry policy에 맞게 stale pending record를 복구하도록 애플리케이션 소유 claim store를 설계하세요.
+
 ### 버전이 명시된 이벤트 키
 
 `static eventKey`를 사용하여 클래스 이름 변경이나 코드 압축(minification)과 관계없이 안정적인 채널 이름을 유지할 수 있습니다.
@@ -104,12 +146,12 @@ class UserRegisteredEvent {
 }
 ```
 
-핸들러는 imported module의 singleton provider와 controller에서 발견됩니다. 각 핸들러는 격리된 clone payload를 받으며, class inheritance는 `instanceof` 매칭으로 지원됩니다. 외부 트랜스포트를 구성하면 subclass event publish는 publisher process에 해당 타입의 local handler가 없더라도 subclass channel과 prototype chain의 모든 inherited event channel로 fan-out됩니다. Subclass가 직접 `static eventKey`를 선언한 경우에만 그 값을 사용하며, 그렇지 않으면 subclass channel은 class name을 유지하고 base class는 자신의 stable key를 유지합니다.
+핸들러는 imported module의 singleton provider와 controller에서 발견됩니다. Discovery는 여러 provider가 같은 구현 class를 공유하더라도 서로 다른 singleton provider identity를 유지하며, 같은 provider token과 handler method가 중복 등록된 경우에는 한 번만 호출합니다. Event-bus bootstrap은 ready 상태를 보고하기 전에 발견된 모든 handler target을 resolve하며, 실제 handler target resolution이 실패하면 handler를 조용히 건너뛰고 ready를 보고하는 대신 bootstrap을 실패시킵니다. Discovery는 이미 handler metadata를 가진 singleton `useValue` instance와 provider token 자체가 `@OnEvent(...)` metadata를 가진 handler class인 singleton `useFactory` provider만 검사하므로, event-bus bootstrap 중 관련 없는 factory provider는 호출되지 않습니다. 각 핸들러는 격리된 clone payload를 받으며, class inheritance는 `instanceof` 매칭으로 지원됩니다. 외부 트랜스포트를 구성하면 subclass event publish는 publisher process에 해당 타입의 local handler가 없더라도 subclass channel과 prototype chain의 모든 inherited event channel로 fan-out됩니다. Subclass가 직접 `static eventKey`를 선언한 경우에만 그 값을 사용하며, 그렇지 않으면 subclass channel은 class name을 유지하고 base class는 자신의 stable key를 유지합니다.
 
 ## 공개 API 개요
 
 ### 핵심 구성 요소
-- `EventBusModule.forRoot(...)`: 이벤트 버스 등록을 위한 기본 진입점입니다.
+- `EventBusModule.forRoot({ global?, publish?, shutdown?, transport? })`: 이벤트 버스 등록을 위한 기본 진입점입니다. `global`의 기본값은 `true`이며, event-bus provider를 event-bus 모듈을 import한 모듈을 통해서만 보이게 하려면 `global: false`를 설정하세요.
 - `EventBusLifecycleService`: 이벤트 발행(`publish(event, options?)`)과 platform status snapshot 생성을 위한 기본 서비스입니다.
 - `@OnEvent(EventClass)`: 특정 메서드를 이벤트 핸들러로 지정하는 데코레이터입니다.
 - `EVENT_BUS`: 발행 facade를 위한 호환성 주입 토큰입니다.
@@ -120,7 +162,7 @@ class UserRegisteredEvent {
 - `EventBus`, `EventPublishOptions`, `EventBusModuleOptions`, `EventType`: 발행, 기본값, 트랜스포트, 안정적인 이벤트 키를 위한 타입 전용 계약입니다.
 - `EventBusLifecycleState`, `EventBusStatusAdapterInput`, `EventBusPlatformStatusSnapshot`: status snapshot 계약입니다.
 
-Transport bootstrap은 unique event channel마다 한 번만 subscribe합니다. `eventKey`가 있으면 transport channel 이름을 제어합니다. 잘못된 JSON transport message는 무시되며, shutdown 시작 뒤 도착한 inbound transport message는 local handler dispatch 전에 무시됩니다.
+Transport bootstrap은 unique event channel마다 한 번만 subscribe합니다. `eventKey`가 있으면 transport channel 이름을 제어합니다. Bootstrap 중 이후 transport subscription이 실패하면 이벤트 버스는 이미 열린 channel을 rollback하기 위해 subscription error를 다시 던지기 전에 transport를 닫습니다. 잘못된 JSON transport message는 무시되며, shutdown 시작 뒤 도착한 inbound transport message는 local handler dispatch 전에 무시됩니다.
 
 ## 런타임별 및 통합 서브패스
 

package/README.md

@@ -10,7 +10,7 @@ In-process event publishing and subscription for fluo. It features decorator-bas
 - [When to use](#when-to-use)
 - [Quick Start](#quick-start)
 - [Common Patterns](#common-patterns)
-- [Public API](#public-api)
+- [Public API Overview](#public-api-overview)
 - [Runtime-Specific and Integration Subpaths](#runtime-specific-and-integration-subpaths)
 - [Related Packages](#related-packages)
 - [Example Sources](#example-sources)
@@ -52,7 +52,7 @@ export class NotificationService {
 
 Import `EventBusModule` and inject `EventBusLifecycleService` to publish events.
 
-Use `EventBusModule.forRoot(...)` to wire the in-process event bus.
+Use `EventBusModule.forRoot(...)` to wire the in-process event bus. Event-bus providers are global by default (`global: true`), so `EventBusLifecycleService` and the `EVENT_BUS` compatibility token are visible to modules that import the root graph. Pass `EventBusModule.forRoot({ global: false })` when you need module-local visibility instead.
 
 ```typescript
 import { Module, Inject } from '@fluojs/core';
@@ -75,7 +75,9 @@ export class UserService {
 export class AppModule {}
 ```
 
-`publish(event, options?)` supports `signal`, `timeoutMs`, and `waitForHandlers`. `waitForHandlers` defaults to `true`; awaited local handlers and awaited transport publishes share the same timeout and cancellation bounds. When `waitForHandlers` is set to `false`, publishing returns immediately and skips timeout bounds. During shutdown, the event bus drains in-flight awaited publish and inbound transport handler work before closing the transport, ignores new publish calls after the lifecycle has started stopping, and ignores inbound transport callbacks that arrive after shutdown begins. Shutdown drain is bounded by `EventBusModule.forRoot({ shutdown: { drainTimeoutMs } })`, which defaults to 5000ms; if active dispatch work is still stuck after the bound, the bus records a degraded status diagnostic, logs a warning, and continues transport cleanup instead of hanging application close indefinitely.
+`publish(event, options?)` supports `signal`, `timeoutMs`, and `waitForHandlers`. `waitForHandlers` defaults to `true`; awaited local handlers and awaited transport publishes share the same timeout and cancellation bounds. When those bounds settle the caller-facing publish promise before the underlying handler or transport work finishes, shutdown still tracks that underlying awaited work until it settles or the shutdown drain bound expires. When `waitForHandlers` is set to `false`, publishing returns immediately and skips timeout bounds, while the handler and transport work continue in the background and remain part of shutdown drain tracking. During shutdown, the event bus drains in-flight awaited and background publish work plus inbound transport handler work before closing the transport, ignores new publish calls after the lifecycle has started stopping, and ignores inbound transport callbacks that arrive after shutdown begins. Shutdown drain is bounded by `EventBusModule.forRoot({ shutdown: { drainTimeoutMs } })`, which defaults to 5000ms; if active dispatch work is still stuck after the bound, the bus records a degraded status diagnostic, logs a warning, and continues transport cleanup instead of hanging application close indefinitely.
+
+**Migration note:** applications that use `waitForHandlers: false` should now budget for `app.close()` to wait up to `shutdown.drainTimeoutMs` for background handler and transport work before transport cleanup continues. Keep that work bounded or configure a drain budget appropriate for the application.
 
 ## Common Patterns
 
@@ -94,6 +96,46 @@ EventBusModule.forRoot({
 })
 ```
 
+Redis Pub/Sub is a fan-out transport, not a durable work queue. When multiple application instances subscribe to the same event channel, each instance can see the same published fact. Handlers that mutate state, send notifications, or call external systems should therefore be idempotent: carry a stable event identifier or business key in the payload, record which reactions have already been applied, and make repeat deliveries converge to the same result instead of performing the side effect twice.
+
+Keep `@OnEvent(...)` handlers small and bounded. They are a good fit for fast local projections, cache invalidation, lightweight notifications, and other reactions that can finish within the publish timeout and shutdown drain window. If a reaction is slow, failure-prone, retryable, or needs operator-visible dead-letter handling, hand off a durable job to `@fluojs/queue` from the event handler instead of doing the work inline. Use an application-owned unique claim for the handoff, then mark the handoff as enqueued only after `queue.enqueue(...)` succeeds; if enqueue fails, release the pending claim so a later duplicate event can retry safely.
+
+The `this.reactions` helper in the example below represents an application-owned claim store, not an API from `@fluojs/event-bus` or `@fluojs/queue`. Back it with storage that can atomically claim a business key and recover stale pending claims according to your application's retry policy.
+
+```typescript
+import { Inject } from '@fluojs/core';
+import { OnEvent } from '@fluojs/event-bus';
+import { QueueLifecycleService } from '@fluojs/queue';
+
+export class GenerateInvoiceJob {
+  constructor(public readonly orderId: string) {}
+}
+
+@Inject(QueueLifecycleService)
+export class BillingEventsHandler {
+  constructor(private readonly queue: QueueLifecycleService) {}
+
+  @OnEvent(OrderPlacedEvent)
+  async enqueueInvoice(event: OrderPlacedEvent) {
+    const handoffKey = `${event.orderId}:invoice`;
+
+    if (!(await this.reactions.claimPending(handoffKey))) {
+      return;
+    }
+
+    try {
+      await this.queue.enqueue(new GenerateInvoiceJob(event.orderId));
+      await this.reactions.markEnqueued(handoffKey);
+    } catch (error) {
+      await this.reactions.releasePending(handoffKey);
+      throw error;
+    }
+  }
+}
+```
+
+Use the event bus to state that a business fact happened. Use Queue when the reaction needs retry, backoff, workload isolation, or dead-letter inspection. If the process can crash while a claim is pending, make the application-owned claim store recover stale pending records according to your application's retry policy.
+
 ### Versioned Event Keys
 
 Use static `eventKey` to ensure stable channel names regardless of class minification or renames.
@@ -104,12 +146,12 @@ class UserRegisteredEvent {
 }
 ```
 
-Handlers are discovered from singleton providers and controllers across imported modules. Each handler receives an isolated cloned payload, and class inheritance is supported through `instanceof` matching. With an external transport configured, publishing a subclass event fans out to the subclass channel and every inherited event channel in its prototype chain, even when the publisher process has no matching local handlers for those types. A subclass uses its own `static eventKey` only when it declares one directly; otherwise its class name remains the subclass channel while base classes keep their own stable keys.
+Handlers are discovered from singleton providers and controllers across imported modules. Discovery keeps distinct singleton provider identities even when multiple providers share the same implementation class; duplicate registration of the same provider token and handler method is invoked only once. Event-bus bootstrap resolves every discovered handler target before reporting ready, and a real handler target resolution failure fails bootstrap instead of silently reporting ready with skipped handlers. Discovery inspects singleton `useValue` instances that already carry handler metadata and singleton `useFactory` providers only when their provider token is the handler class with `@OnEvent(...)` metadata, so unrelated factory providers are not invoked during event-bus bootstrap. Each handler receives an isolated cloned payload, and class inheritance is supported through `instanceof` matching. With an external transport configured, publishing a subclass event fans out to the subclass channel and every inherited event channel in its prototype chain, even when the publisher process has no matching local handlers for those types. A subclass uses its own `static eventKey` only when it declares one directly; otherwise its class name remains the subclass channel while base classes keep their own stable keys.
 
 ## Public API Overview
 
 ### Core
-- `EventBusModule.forRoot(...)`: Main entry point for event bus registration.
+- `EventBusModule.forRoot({ global?, publish?, shutdown?, transport? })`: Main entry point for event bus registration. `global` defaults to `true`; set `global: false` to keep event-bus providers visible only through the module that imports the event-bus module.
 - `EventBusLifecycleService`: Primary service for publishing events (`publish(event, options?)`) and creating platform status snapshots.
 - `@OnEvent(EventClass)`: Decorator to mark a method as an event handler.
 - `EVENT_BUS`: Compatibility injection token for the publish facade.
@@ -120,7 +162,7 @@ Handlers are discovered from singleton providers and controllers across imported
 - `EventBus`, `EventPublishOptions`, `EventBusModuleOptions`, `EventType`: Type-only contracts for publishing, defaults, transports, and stable event keys.
 - `EventBusLifecycleState`, `EventBusStatusAdapterInput`, `EventBusPlatformStatusSnapshot`: Status snapshot contracts.
 
-Transport bootstrap subscribes once per unique event channel. `eventKey` controls the transport channel name when present. Invalid JSON transport messages are ignored, and inbound transport messages that arrive after shutdown starts are ignored before local handler dispatch.
+Transport bootstrap subscribes once per unique event channel. `eventKey` controls the transport channel name when present. If a later transport subscription fails during bootstrap, the event bus closes the transport to roll back any channels that were already opened before rethrowing the subscription error. Invalid JSON transport messages are ignored, and inbound transport messages that arrive after shutdown starts are ignored before local handler dispatch.
 
 ## Runtime-Specific and Integration Subpaths
 

package/dist/service.d.ts

@@ -1,5 +1,5 @@
 import type { Container } from '@fluojs/di';
-import { type ApplicationLogger, type CompiledModule, type OnApplicationBootstrap, type OnApplicationShutdown } from '@fluojs/runtime';
+import type { ApplicationLogger, CompiledModule, OnApplicationBootstrap, OnApplicationShutdown } from '@fluojs/runtime';
 import type { EventBus, EventBusModuleOptions, EventPublishOptions } from './types.js';
 /**
  * Lifecycle-managed in-process event bus with optional external transport fan-out.
@@ -24,6 +24,7 @@ export declare class EventBusLifecycleService implements EventBus, OnApplication
     private shutdownDrainTimeouts;
     private readonly activeDispatches;
     private readonly transport;
+    private transportClosed;
     constructor(runtimeContainer: Container, compiledModules: readonly CompiledModule[], logger: ApplicationLogger, moduleOptions: EventBusModuleOptions);
     onApplicationBootstrap(): Promise<void>;
     onApplicationShutdown(): Promise<void>;
@@ -45,6 +46,7 @@ export declare class EventBusLifecycleService implements EventBus, OnApplication
     private canPublishInCurrentLifecycle;
     private drainActiveDispatches;
     private trackActiveDispatch;
+    private trackActiveDispatchWork;
     private awaitShutdownDrain;
     private resolveShutdownDrainTimeoutMs;
     private matchEventDescriptors;
@@ -63,6 +65,9 @@ export declare class EventBusLifecycleService implements EventBus, OnApplication
     private logTransportPublishCancelledBeforeDispatch;
     private logBoundedTransportPublishError;
     private subscribeTransportChannels;
+    private rollbackTransportSubscriptionsAfterBootstrapFailure;
+    private closeTransportOrRecordFailure;
+    private closeTransport;
     private subscribeTransportChannel;
     private canDispatchIncomingTransportMessage;
     private dispatchIncomingTransportMessage;
@@ -79,6 +84,8 @@ export declare class EventBusLifecycleService implements EventBus, OnApplication
     private isDuplicateHandlerRegistration;
     private createHandlerDescriptor;
     private discoveryCandidates;
+    private resolveProviderDiscoveryCandidate;
+    private createUnresolvedProviderDiscoveryCandidate;
     private invokeHandler;
     private resolveHandlerInstance;
 }

package/dist/service.d.ts.map

@@ -1 +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;AAgEpB;;;;;GAKG;AACH,qBACa,wBAAyB,YAAW,QAAQ,EAAE,sBAAsB,EAAE,qBAAqB;IAepG,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAjBhC,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,qBAAqB,CAAK;IAClC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA4B;IAC7D,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;IAsB5C;;;;OAIG;IACH,4BAA4B;IAe5B;;;;;;OAMG;IACG,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;YAY5D,cAAc;IA+B5B,OAAO,CAAC,4BAA4B;YAItB,qBAAqB;YAcrB,mBAAmB;YAUnB,kBAAkB;IAiBhC,OAAO,CAAC,6BAA6B;IAIrC,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;IAkBnC,OAAO,CAAC,gBAAgB;YAiBV,kBAAkB;IA8BhC,OAAO,CAAC,0CAA0C;IAOlD,OAAO,CAAC,+BAA+B;YAwBzB,0BAA0B;YAmB1B,yBAAyB;IAiCvC,OAAO,CAAC,mCAAmC;YAI7B,gCAAgC;YAmBhC,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"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAY,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAMxH,OAAO,KAAK,EACV,QAAQ,EACR,qBAAqB,EAGrB,mBAAmB,EAEpB,MAAM,YAAY,CAAC;AA6EpB;;;;;GAKG;AACH,qBACa,wBAAyB,YAAW,QAAQ,EAAE,sBAAsB,EAAE,qBAAqB;IAgBpG,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,aAAa;IAlBhC,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,qBAAqB,CAAK;IAClC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA4B;IAC7D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgC;IAC1D,OAAO,CAAC,eAAe,CAAS;gBAGb,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;IAiB5C;;;;OAIG;IACH,4BAA4B;IAe5B;;;;;;OAMG;IACG,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;YAY5D,cAAc;IA+B5B,OAAO,CAAC,4BAA4B;YAItB,qBAAqB;YAcrB,mBAAmB;IAUjC,OAAO,CAAC,uBAAuB;YAajB,kBAAkB;IAiBhC,OAAO,CAAC,6BAA6B;IAIrC,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;IAkBnC,OAAO,CAAC,gBAAgB;YAiBV,kBAAkB;IAgChC,OAAO,CAAC,0CAA0C;IAOlD,OAAO,CAAC,+BAA+B;YAwBzB,0BAA0B;YAwB1B,mDAAmD;YAInD,6BAA6B;YAa7B,cAAc;YAYd,yBAAyB;IAiCvC,OAAO,CAAC,mCAAmC;YAI7B,gCAAgC;YAmBhC,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;YAmBV,0BAA0B;IAyBxC,OAAO,CAAC,+BAA+B;IAevC,OAAO,CAAC,8BAA8B;IA4BtC,OAAO,CAAC,uBAAuB;YAejB,mBAAmB;IAoDjC,OAAO,CAAC,iCAAiC;IA+CzC,OAAO,CAAC,0CAA0C;YAmBpC,aAAa;YAwBb,sBAAsB;CAsBrC"}

package/dist/service.js

@@ -44,6 +44,12 @@ function methodKeyToName(methodKey) {
 function isClassProvider(provider) {
   return typeof provider === 'object' && provider !== null && 'useClass' in provider;
 }
+function isFactoryOrValueProvider(provider) {
+  return typeof provider === 'object' && provider !== null && ('useFactory' in provider || 'useValue' in provider);
+}
+function hasEventHandlerMetadata(targetType) {
+  return getEventHandlerMetadataEntries(targetType.prototype).length > 0;
+}
 
 /**
  * Lifecycle-managed in-process event bus with optional external transport fan-out.
@@ -68,6 +74,7 @@ class EventBusLifecycleService {
   shutdownDrainTimeouts = 0;
   activeDispatches = new Set();
   transport;
+  transportClosed = false;
   constructor(runtimeContainer, compiledModules, logger, moduleOptions) {
     this.runtimeContainer = runtimeContainer;
     this.compiledModules = compiledModules;
@@ -88,19 +95,14 @@ class EventBusLifecycleService {
   }
   async onApplicationShutdown() {
     this.lifecycleState = 'stopping';
+    let transportClosedCleanly = true;
     if (this.activeDispatches.size > 0) {
       await this.drainActiveDispatches();
     }
     if (this.transport) {
-      try {
-        await this.transport.close();
-      } catch (error) {
-        this.transportCloseFailures += 1;
-        this.lifecycleState = 'failed';
-        this.logger.error('EventBusTransport failed to close.', error, 'EventBusLifecycleService');
-      }
+      transportClosedCleanly = await this.closeTransportOrRecordFailure('EventBusTransport failed to close.');
     }
-    if (this.lifecycleState !== 'failed') {
+    if (transportClosedCleanly) {
       this.lifecycleState = 'stopped';
     }
   }
@@ -181,6 +183,14 @@ class EventBusLifecycleService {
       this.activeDispatches.delete(dispatchWorkflow);
     }
   }
+  trackActiveDispatchWork(dispatchWork) {
+    const trackedWork = dispatchWork.then(() => undefined, () => undefined);
+    this.activeDispatches.add(trackedWork);
+    void trackedWork.finally(() => {
+      this.activeDispatches.delete(trackedWork);
+    });
+    return dispatchWork;
+  }
   async awaitShutdownDrain(activePublishes, timeoutMs) {
     let timeoutId;
     const timeout = new Promise(resolve => {
@@ -215,7 +225,7 @@ class EventBusLifecycleService {
   }
   runInvocationTasksInBackground(invocationTasks) {
     for (const task of invocationTasks) {
-      void task;
+      void this.trackActiveDispatchWork(task);
     }
   }
   async invokeHandlerInBackground(descriptor, event, signal) {
@@ -257,7 +267,7 @@ class EventBusLifecycleService {
   }
   async discoverHandlers() {
     try {
-      this.descriptors = this.discoverHandlerDescriptors();
+      this.descriptors = await this.discoverHandlerDescriptors();
       this.handlerInstances.clear();
       await this.preloadHandlerInstances(this.descriptors);
       this.discovered = true;
@@ -311,7 +321,9 @@ class EventBusLifecycleService {
         return;
       }
       try {
-        await this.awaitInvocationBounds(this.transport.publish(channel, payload), publishOptions);
+        const publishWork = this.transport.publish(channel, payload);
+        const trackedPublishWork = this.trackActiveDispatchWork(publishWork);
+        await this.awaitInvocationBounds(trackedPublishWork, publishOptions);
       } catch (error) {
         this.transportPublishFailures += 1;
         this.logBoundedTransportPublishError(channel, error);
@@ -344,9 +356,37 @@ class EventBusLifecycleService {
       channelDescriptors.push(descriptor);
       descriptorsByChannel.set(channel, channelDescriptors);
     }
-    for (const [channel, channelDescriptors] of descriptorsByChannel) {
-      await this.subscribeTransportChannel(channel, channelDescriptors);
+    try {
+      for (const [channel, channelDescriptors] of descriptorsByChannel) {
+        await this.subscribeTransportChannel(channel, channelDescriptors);
+      }
+    } catch (error) {
+      await this.rollbackTransportSubscriptionsAfterBootstrapFailure();
+      throw error;
+    }
+  }
+  async rollbackTransportSubscriptionsAfterBootstrapFailure() {
+    await this.closeTransportOrRecordFailure('EventBusTransport failed to close after bootstrap subscription failure.');
+  }
+  async closeTransportOrRecordFailure(message) {
+    try {
+      await this.closeTransport();
+      return true;
+    } catch (error) {
+      this.transportCloseFailures += 1;
+      this.lifecycleState = 'failed';
+      this.logger.error(message, error, 'EventBusLifecycleService');
+      return false;
+    }
+  }
+  async closeTransport() {
+    const transport = this.transport;
+    if (!transport || this.transportClosed) {
+      return;
     }
+    await transport.close();
+    this.transportClosed = true;
+    this.subscribedChannels.clear();
   }
   async subscribeTransportChannel(channel, channelDescriptors) {
     try {
@@ -391,7 +431,7 @@ class EventBusLifecycleService {
       this.logPublishCancelledBeforeDispatch(descriptor);
       return;
     }
-    const invocation = this.invokeHandler(descriptor, event);
+    const invocation = this.trackActiveDispatchWork(this.invokeHandler(descriptor, event));
     try {
       await this.awaitInvocationBounds(invocation, publishOptions);
     } catch (error) {
@@ -474,17 +514,17 @@ class EventBusLifecycleService {
       })
     };
   }
-  discoverHandlerDescriptors() {
-    const seen = new WeakMap();
+  async discoverHandlerDescriptors() {
+    const seen = new Map();
     const descriptors = [];
-    for (const candidate of this.discoveryCandidates()) {
+    for (const candidate of await this.discoveryCandidates()) {
       const entries = getEventHandlerMetadataEntries(candidate.targetType.prototype);
       if (this.shouldSkipNonSingletonCandidate(candidate, entries.length)) {
         continue;
       }
       for (const entry of entries) {
         const eventType = entry.metadata.eventType;
-        if (this.isDuplicateHandlerRegistration(seen, candidate.targetType, entry.propertyKey, eventType)) {
+        if (this.isDuplicateHandlerRegistration(seen, candidate.token, entry.propertyKey, eventType)) {
           continue;
         }
         descriptors.push(this.createHandlerDescriptor(candidate, entry.propertyKey, eventType));
@@ -501,11 +541,11 @@ class EventBusLifecycleService {
     }
     return true;
   }
-  isDuplicateHandlerRegistration(seen, targetType, methodKey, eventType) {
-    let methodsByKey = seen.get(targetType);
+  isDuplicateHandlerRegistration(seen, token, methodKey, eventType) {
+    let methodsByKey = seen.get(token);
     if (!methodsByKey) {
       methodsByKey = new Map();
-      seen.set(targetType, methodsByKey);
+      seen.set(token, methodsByKey);
     }
     let seenEventTypes = methodsByKey.get(methodKey);
     if (!seenEventTypes) {
@@ -528,8 +568,9 @@ class EventBusLifecycleService {
       token: candidate.token
     };
   }
-  discoveryCandidates() {
+  async discoveryCandidates() {
     const candidates = [];
+    const providerCandidates = [];
     for (const compiledModule of this.compiledModules) {
       for (const provider of compiledModule.definition.providers ?? []) {
         if (typeof provider === 'function') {
@@ -548,6 +589,13 @@ class EventBusLifecycleService {
             targetType: provider.useClass,
             token: provider.provide
           });
+          continue;
+        }
+        if (isFactoryOrValueProvider(provider)) {
+          providerCandidates.push({
+            moduleName: compiledModule.type.name,
+            provider
+          });
         }
       }
       for (const controller of compiledModule.definition.controllers ?? []) {
@@ -559,13 +607,64 @@ class EventBusLifecycleService {
         });
       }
     }
+    for (const candidate of providerCandidates) {
+      const resolvedCandidate = await this.resolveProviderDiscoveryCandidate(candidate);
+      if (resolvedCandidate) {
+        candidates.push(resolvedCandidate);
+      }
+    }
     return candidates;
   }
+  resolveProviderDiscoveryCandidate(candidate) {
+    const provider = candidate.provider;
+    if (!('provide' in provider)) {
+      return undefined;
+    }
+    const scope = scopeFromProvider(provider);
+    const token = provider.provide;
+    if (scope !== 'singleton') {
+      return this.createUnresolvedProviderDiscoveryCandidate(candidate.moduleName, token, scope);
+    }
+    if ('useValue' in provider) {
+      const instance = provider.useValue;
+      if (typeof instance !== 'object' || instance === null) {
+        return undefined;
+      }
+      const targetType = instance.constructor;
+      if (typeof targetType !== 'function' || !hasEventHandlerMetadata(targetType)) {
+        return undefined;
+      }
+      return {
+        moduleName: candidate.moduleName,
+        scope,
+        targetType,
+        token
+      };
+    }
+    if (typeof token !== 'function' || !hasEventHandlerMetadata(token)) {
+      return undefined;
+    }
+    return {
+      moduleName: candidate.moduleName,
+      scope,
+      targetType: token,
+      token
+    };
+  }
+  createUnresolvedProviderDiscoveryCandidate(moduleName, token, scope) {
+    const tokenType = typeof token === 'function' ? token : undefined;
+    if (!tokenType) {
+      return undefined;
+    }
+    return {
+      moduleName,
+      scope,
+      targetType: tokenType,
+      token
+    };
+  }
   async invokeHandler(descriptor, event) {
     const instance = await this.resolveHandlerInstance(descriptor);
-    if (instance === undefined) {
-      return;
-    }
     const value = instance[descriptor.methodKey];
     if (typeof value !== 'function') {
       this.logger.warn(`Event handler ${descriptor.targetName}.${descriptor.methodName} is not callable and was skipped.`, 'EventBusLifecycleService');
@@ -589,7 +688,7 @@ class EventBusLifecycleService {
     } catch (error) {
       this.handlerInstances.delete(descriptor.token);
       this.logger.error(`Failed to resolve event handler target ${descriptor.targetName} from module ${descriptor.moduleName}.`, error, 'EventBusLifecycleService');
-      return undefined;
+      throw error;
     }
   }
   static {

package/dist/types.d.ts

@@ -27,7 +27,8 @@ export interface EventPublishOptions {
 export interface EventBusTransport {
     /**
      * Publish an event payload to the external transport under the given channel name.
-     * Called by the event bus on every local `publish()` invocation when a transport is configured.
+     * Called for each selected transport channel when a transport is configured; one local
+     * `publish()` invocation can fan out to multiple inherited event channels.
      */
     publish(channel: string, payload: unknown): Promise<void>;
     /**

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAE/D,qGAAqG;AACrG,MAAM,WAAW,SAAS,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM;IACvD,KAAK,GAAG,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,0CAA0C;AAC1C,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,SAAS,CAAC;CACtB;AAED,kEAAkE;AAClE,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,mBAAmB,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC;CACd;AAED,8EAA8E;AAC9E,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,kGAAkG;AAClG,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1D;;;;OAIG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAExF;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,sFAAsF;AACtF,MAAM,WAAW,qBAAqB;IACpC,kFAAkF;IAClF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,eAAe,CAAC,EAAE,OAAO,CAAC;KAC3B,CAAC;IACF,kEAAkE;IAClE,QAAQ,CAAC,EAAE;QACT,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC;IACF;;;;OAIG;IACH,SAAS,CAAC,EAAE,iBAAiB,CAAC;CAC/B;AAED,+DAA+D;AAC/D,MAAM,WAAW,QAAQ;IACvB;;;;;;OAMG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtE"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAE/D,qGAAqG;AACrG,MAAM,WAAW,SAAS,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM;IACvD,KAAK,GAAG,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,0CAA0C;AAC1C,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,SAAS,CAAC;CACtB;AAED,kEAAkE;AAClE,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,mBAAmB,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC;CACd;AAED,8EAA8E;AAC9E,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,kGAAkG;AAClG,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1D;;;;OAIG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAExF;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,sFAAsF;AACtF,MAAM,WAAW,qBAAqB;IACpC,kFAAkF;IAClF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,eAAe,CAAC,EAAE,OAAO,CAAC;KAC3B,CAAC;IACF,kEAAkE;IAClE,QAAQ,CAAC,EAAE;QACT,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC;IACF;;;;OAIG;IACH,SAAS,CAAC,EAAE,iBAAiB,CAAC;CAC/B;AAED,+DAA+D;AAC/D,MAAM,WAAW,QAAQ;IACvB;;;;;;OAMG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACtE"}

package/package.json

@@ -8,7 +8,7 @@
     "pubsub",
     "in-process"
   ],
-  "version": "1.0.0",
+  "version": "2.0.0",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -39,9 +39,9 @@
     "dist"
   ],
   "dependencies": {
-    "@fluojs/core": "^1.0.0",
-    "@fluojs/di": "^1.0.0",
-    "@fluojs/runtime": "^1.0.0"
+    "@fluojs/core": "^1.1.0",
+    "@fluojs/di": "^2.0.0",
+    "@fluojs/runtime": "^2.0.1"
   },
   "peerDependencies": {
     "ioredis": "^5.0.0"