@fluojs/event-bus 1.0.0-beta.7 → 1.0.1

package/README.ko.md

@@ -75,7 +75,7 @@ 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를 적용하지 않습니다. 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을 계속합니다.
 
 ## 일반적인 패턴
 
@@ -94,6 +94,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,7 +144,7 @@ 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가 중복 등록된 경우에는 한 번만 호출합니다. 각 핸들러는 격리된 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 개요
 
@@ -120,7 +160,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

@@ -75,7 +75,7 @@ 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. 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.
 
 ## Common Patterns
 
@@ -94,6 +94,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,7 +144,7 @@ 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. 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
 
@@ -120,7 +160,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;

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;AAgEpB;;;;;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;IAkChC,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;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"}

package/dist/service.js

@@ -68,6 +68,7 @@ class EventBusLifecycleService {
   shutdownDrainTimeouts = 0;
   activeDispatches = new Set();
   transport;
+  transportClosed = false;
   constructor(runtimeContainer, compiledModules, logger, moduleOptions) {
     this.runtimeContainer = runtimeContainer;
     this.compiledModules = compiledModules;
@@ -88,19 +89,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 +177,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 => {
@@ -311,7 +315,9 @@ class EventBusLifecycleService {
         return;
       }
       try {
-        await this.awaitInvocationBounds(this.transport.publish(channel, payload), publishOptions);
+        const publishWork = this.transport.publish(channel, payload);
+        const boundedPublishWork = publishOptions.waitForHandlers ? this.trackActiveDispatchWork(publishWork) : publishWork;
+        await this.awaitInvocationBounds(boundedPublishWork, publishOptions);
       } catch (error) {
         this.transportPublishFailures += 1;
         this.logBoundedTransportPublishError(channel, error);
@@ -344,9 +350,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 +425,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) {
@@ -475,7 +509,7 @@ class EventBusLifecycleService {
     };
   }
   discoverHandlerDescriptors() {
-    const seen = new WeakMap();
+    const seen = new Map();
     const descriptors = [];
     for (const candidate of this.discoveryCandidates()) {
       const entries = getEventHandlerMetadataEntries(candidate.targetType.prototype);
@@ -484,7 +518,7 @@ class EventBusLifecycleService {
       }
       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 +535,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) {

package/package.json

@@ -8,7 +8,7 @@
     "pubsub",
     "in-process"
   ],
-  "version": "1.0.0-beta.7",
+  "version": "1.0.1",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -39,9 +39,9 @@
     "dist"
   ],
   "dependencies": {
-    "@fluojs/core": "^1.0.0-beta.6",
-    "@fluojs/di": "^1.0.0-beta.8",
-    "@fluojs/runtime": "^1.0.0-beta.12"
+    "@fluojs/core": "^1.0.3",
+    "@fluojs/di": "^1.1.0",
+    "@fluojs/runtime": "^1.1.8"
   },
   "peerDependencies": {
     "ioredis": "^5.0.0"