@haskou/ddd-kernel 0.1.1 → 1.0.1

package/README.md

@@ -4,6 +4,7 @@
 [![codecov](https://codecov.io/gh/haskou/ddd-kernel/branch/main/graph/badge.svg)](https://codecov.io/gh/haskou/ddd-kernel)
 [![npm](https://img.shields.io/npm/v/@haskou/ddd-kernel.svg)](https://www.npmjs.com/package/@haskou/ddd-kernel)
 [![license](https://img.shields.io/npm/l/@haskou/ddd-kernel.svg)](LICENSE)
+[![Renovate](https://img.shields.io/badge/renovate-enabled-brightgreen.svg)](https://renovatebot.com)
 
 Framework-agnostic DDD kernel for TypeScript applications and microservices.
 
@@ -44,12 +45,6 @@ Constructor injection is the preferred application pattern. Direct service
 lookup remains available for compatibility and integration boundaries, but it is
 not the primary dependency model.
 
-## Stability
-
-This project is still in the `0.x` line. The current API is intentionally small
-and covered by tests, but breaking changes may still happen while the kernel is
-being extracted and hardened from production service patterns.
-
 ## Documentation
 
 Usage guides, adapter authoring notes and API reference pages are published at:
@@ -65,10 +60,10 @@ CI publishes npm versions from pull requests merged into the default branch
 according to the source branch prefix:
 
 | Branch prefix | npm version bump |
-| --- | --- |
-| `fix/*` | Patch |
-| `feat/*` | Minor |
-| `break/*` | Major |
+| ------------- | ---------------- |
+| `fix/*`       | Patch            |
+| `feat/*`      | Minor            |
+| `break/*`     | Major            |
 
 Other branch names run validation only and do not publish.
 

package/dist/DomainEventConsumer-Bg-bOwmh.d.cts

@@ -0,0 +1,11 @@
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.cjs';
+
+interface DomainEventConsumerContext {
+    readonly metadata: Readonly<Record<string, unknown>>;
+}
+
+declare abstract class DomainEventConsumer {
+    abstract consume(queueName: string, bindingKey: string, domainEvent: typeof DomainEvent, exchange: string, handler: (event: DomainEvent, context?: DomainEventConsumerContext) => Promise<void>): Promise<void>;
+}
+
+export { DomainEventConsumer as D, type DomainEventConsumerContext as a };

package/dist/DomainEventConsumer-BroJmVty.d.ts

@@ -0,0 +1,11 @@
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.js';
+
+interface DomainEventConsumerContext {
+    readonly metadata: Readonly<Record<string, unknown>>;
+}
+
+declare abstract class DomainEventConsumer {
+    abstract consume(queueName: string, bindingKey: string, domainEvent: typeof DomainEvent, exchange: string, handler: (event: DomainEvent, context?: DomainEventConsumerContext) => Promise<void>): Promise<void>;
+}
+
+export { DomainEventConsumer as D, type DomainEventConsumerContext as a };

package/dist/DomainMessageBus-3jYk7TPw.d.ts

@@ -0,0 +1,13 @@
+import { M as MessageBus } from './MessageBus-oQ9BnW84.js';
+import { D as DomainEventConsumer } from './DomainEventConsumer-BroJmVty.js';
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.js';
+
+declare abstract class DomainEventPublisher {
+    abstract publish(domainEvents: DomainEvent[]): Promise<void>;
+}
+
+interface DomainMessageBus extends DomainEventConsumer, DomainEventPublisher {
+    registerPublisherHooks: MessageBus['registerPublisherHooks'];
+}
+
+export { DomainEventPublisher as D, type DomainMessageBus as a };

package/dist/DomainMessageBus-OyliPu3Z.d.cts

@@ -0,0 +1,13 @@
+import { M as MessageBus } from './MessageBus-BtUXnd0Y.cjs';
+import { D as DomainEventConsumer } from './DomainEventConsumer-Bg-bOwmh.cjs';
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.cjs';
+
+declare abstract class DomainEventPublisher {
+    abstract publish(domainEvents: DomainEvent[]): Promise<void>;
+}
+
+interface DomainMessageBus extends DomainEventConsumer, DomainEventPublisher {
+    registerPublisherHooks: MessageBus['registerPublisherHooks'];
+}
+
+export { DomainEventPublisher as D, type DomainMessageBus as a };

package/dist/MessageBus-BtUXnd0Y.d.cts

@@ -0,0 +1,10 @@
+import { M as Message } from './HandlerContext-Lm89pSeG.cjs';
+import { a as PublisherHook, M as MessageHandler, S as Subscription } from './Subscription-4vuAAxax.cjs';
+
+interface MessageBus {
+    publish<TMessage extends Message>(topic: string, message: TMessage): Promise<void>;
+    registerPublisherHooks(...hooks: PublisherHook[]): void;
+    subscribe<TMessage extends Message>(topic: string, consumer: MessageHandler<TMessage, void>): Promise<Subscription>;
+}
+
+export type { MessageBus as M };

package/dist/MessageBus-oQ9BnW84.d.ts

@@ -0,0 +1,10 @@
+import { M as Message } from './HandlerContext-DUUExVo3.js';
+import { a as PublisherHook, M as MessageHandler, S as Subscription } from './Subscription-vtF0lEHP.js';
+
+interface MessageBus {
+    publish<TMessage extends Message>(topic: string, message: TMessage): Promise<void>;
+    registerPublisherHooks(...hooks: PublisherHook[]): void;
+    subscribe<TMessage extends Message>(topic: string, consumer: MessageHandler<TMessage, void>): Promise<Subscription>;
+}
+
+export type { MessageBus as M };

package/dist/{NoFailedMessagesError-0YJKRWPF.d.ts → NoFailedMessagesError-BLpGI-G4.d.ts}

@@ -1,7 +1,10 @@
+import { a as PublisherHook } from './Subscription-vtF0lEHP.js';
 import { L as Log } from './Log-36L3Z84a.js';
+import { P as PublisherHookErrorPolicy } from './PublisherHookErrorPolicy-DSsCNE6O.js';
 import { Channel } from 'amqplib';
 import { D as DomainEvent } from './DomainEvent-mXWEtr_J.js';
 import { C as Constructor } from './Constructor-fyZLLIh8.js';
+import { a as DomainEventConsumerContext } from './DomainEventConsumer-BroJmVty.js';
 
 type AmqpMessage = {
     readonly aggregate_id: string;
@@ -20,11 +23,13 @@ interface AmqpMessageBusAdapterOptions {
     readonly exchange?: string;
     readonly logger?: Log;
     readonly maxRetries?: number;
+    readonly publisherHookErrorPolicy?: PublisherHookErrorPolicy;
+    readonly publisherHooks?: PublisherHook[];
     readonly retryDelayInMilliseconds?: number;
     readonly serviceName?: string;
 }
 
-type DomainEventHandler = (event: DomainEvent) => Promise<void>;
+type DomainEventHandler = (event: DomainEvent, context?: DomainEventConsumerContext) => Promise<void>;
 
 type ConsumerContext = {
     readonly bindingKey: string;

package/dist/{NoFailedMessagesError-Kz7CYWpT.d.cts → NoFailedMessagesError-BjxYoKTR.d.cts}

@@ -1,7 +1,10 @@
+import { a as PublisherHook } from './Subscription-4vuAAxax.cjs';
 import { L as Log } from './Log-36L3Z84a.cjs';
+import { P as PublisherHookErrorPolicy } from './PublisherHookErrorPolicy-CjouTcSR.cjs';
 import { Channel } from 'amqplib';
 import { D as DomainEvent } from './DomainEvent-mXWEtr_J.cjs';
 import { C as Constructor } from './Constructor-fyZLLIh8.cjs';
+import { a as DomainEventConsumerContext } from './DomainEventConsumer-Bg-bOwmh.cjs';
 
 type AmqpMessage = {
     readonly aggregate_id: string;
@@ -20,11 +23,13 @@ interface AmqpMessageBusAdapterOptions {
     readonly exchange?: string;
     readonly logger?: Log;
     readonly maxRetries?: number;
+    readonly publisherHookErrorPolicy?: PublisherHookErrorPolicy;
+    readonly publisherHooks?: PublisherHook[];
     readonly retryDelayInMilliseconds?: number;
     readonly serviceName?: string;
 }
 
-type DomainEventHandler = (event: DomainEvent) => Promise<void>;
+type DomainEventHandler = (event: DomainEvent, context?: DomainEventConsumerContext) => Promise<void>;
 
 type ConsumerContext = {
     readonly bindingKey: string;

package/dist/PublisherHookErrorPolicy-CjouTcSR.d.cts

@@ -0,0 +1,8 @@
+import { P as PublishContext } from './Subscription-4vuAAxax.cjs';
+
+interface PublisherHookErrorPolicy {
+    handleAfterPublishError(error: unknown, context: PublishContext): Promise<void> | void;
+    shouldFailAfterPublish(error: unknown, context: PublishContext): boolean;
+}
+
+export type { PublisherHookErrorPolicy as P };

package/dist/PublisherHookErrorPolicy-DSsCNE6O.d.ts

@@ -0,0 +1,8 @@
+import { P as PublishContext } from './Subscription-vtF0lEHP.js';
+
+interface PublisherHookErrorPolicy {
+    handleAfterPublishError(error: unknown, context: PublishContext): Promise<void> | void;
+    shouldFailAfterPublish(error: unknown, context: PublishContext): boolean;
+}
+
+export type { PublisherHookErrorPolicy as P };

package/dist/RetryPredicate-U7dYnQ4N.d.ts

@@ -0,0 +1,15 @@
+import { a as ConsumerExecutionContext } from './ShutdownHook-CMWLsfu-.js';
+
+interface IdempotencyStore {
+    claim?(key: string): Promise<boolean> | boolean;
+    commit?(key: string): Promise<void> | void;
+    release?(key: string): Promise<void> | void;
+    has(key: string): Promise<boolean> | boolean;
+    mark(key: string): Promise<void> | void;
+}
+
+type RetryDelayResolver = (attempt: number, error: unknown, context: ConsumerExecutionContext) => number | Promise<number>;
+
+type RetryPredicate = (error: unknown, attempt: number, context: ConsumerExecutionContext) => boolean | Promise<boolean>;
+
+export type { IdempotencyStore as I, RetryDelayResolver as R, RetryPredicate as a };

package/dist/RetryPredicate-yT_z9zk1.d.cts

@@ -0,0 +1,15 @@
+import { a as ConsumerExecutionContext } from './ShutdownHook-BjbnCKzr.cjs';
+
+interface IdempotencyStore {
+    claim?(key: string): Promise<boolean> | boolean;
+    commit?(key: string): Promise<void> | void;
+    release?(key: string): Promise<void> | void;
+    has(key: string): Promise<boolean> | boolean;
+    mark(key: string): Promise<void> | void;
+}
+
+type RetryDelayResolver = (attempt: number, error: unknown, context: ConsumerExecutionContext) => number | Promise<number>;
+
+type RetryPredicate = (error: unknown, attempt: number, context: ConsumerExecutionContext) => boolean | Promise<boolean>;
+
+export type { IdempotencyStore as I, RetryDelayResolver as R, RetryPredicate as a };

package/dist/{Scheduler-oigqNOUJ.d.ts → Scheduler-BW-U5Ccg.d.cts}

@@ -24,4 +24,4 @@ declare abstract class Scheduler {
     init(): Promise<void>;
 }
 
-export { type CronExpression as C, Scheduler as S, type SchedulerErrorPolicy as a };
+export { type CronExpression as C, type SchedulerErrorPolicy as S, Scheduler as a };

package/dist/{Scheduler-oigqNOUJ.d.cts → Scheduler-BW-U5Ccg.d.ts}

@@ -24,4 +24,4 @@ declare abstract class Scheduler {
     init(): Promise<void>;
 }
 
-export { type CronExpression as C, Scheduler as S, type SchedulerErrorPolicy as a };
+export { type CronExpression as C, type SchedulerErrorPolicy as S, Scheduler as a };

package/dist/ServiceClass-BkEHcXDi.d.cts

@@ -0,0 +1,72 @@
+import { S as ServiceResolver } from './ServiceResolver-D2Jz-l_Z.cjs';
+
+type DependencyOverrideToken = unknown;
+
+interface ClassDependencyOverride {
+    readonly token: DependencyOverrideToken;
+    readonly useClass: new (...args: never[]) => unknown;
+}
+
+type DependencyOverrideFactory = (resolver: ServiceResolver) => unknown;
+
+interface FactoryDependencyOverride {
+    readonly token: DependencyOverrideToken;
+    readonly useFactory: DependencyOverrideFactory;
+}
+
+interface ValueDependencyOverride {
+    readonly token: DependencyOverrideToken;
+    readonly useValue: unknown;
+}
+
+type DependencyOverride = ClassDependencyOverride | FactoryDependencyOverride | ValueDependencyOverride;
+
+interface DependencyInjectionOptions {
+    readonly containerBuild?: boolean;
+    readonly overrides?: readonly DependencyOverride[];
+    readonly servicesYamlPath: string;
+    readonly sourceDirectory: string;
+}
+
+declare class DependencyInjection implements ServiceResolver {
+    private readonly options;
+    private static configuredInstance;
+    private autowire;
+    private loader;
+    private readonly container;
+    private readonly overrideTokenIds;
+    static configure(options: DependencyInjectionOptions): DependencyInjection;
+    static get instance(): DependencyInjection;
+    constructor(options?: DependencyInjectionOptions);
+    private get definitions();
+    private get aliases();
+    private ensureFolderExists;
+    private getServiceClassName;
+    private getOverrideId;
+    private ensureSyntheticService;
+    private parentMatchesService;
+    private serviceIdMatchesService;
+    private serviceIdReferencesService;
+    private getReferenceId;
+    private getDefinitionArgumentReferences;
+    private findConcreteChildServiceId;
+    private findRegisteredServiceId;
+    private findAliasServiceId;
+    private findReferencedServiceIds;
+    private getOverrideTokenIds;
+    private getOverrideClassServiceId;
+    private applyClassOverride;
+    private applyFactoryOverride;
+    private applyValueOverride;
+    private applyOverrides;
+    private registerParentAliases;
+    compile(): Promise<void>;
+    getService<T>(serviceName: unknown): T;
+}
+
+type ServiceClass<T> = {
+    readonly prototype: T;
+    new (...args: never[]): T;
+};
+
+export { type ClassDependencyOverride as C, DependencyInjection as D, type FactoryDependencyOverride as F, type ServiceClass as S, type ValueDependencyOverride as V, type DependencyInjectionOptions as a, type DependencyOverride as b, type DependencyOverrideFactory as c, type DependencyOverrideToken as d };

package/dist/ServiceClass-Bq_fBC5R.d.ts

@@ -0,0 +1,72 @@
+import { S as ServiceResolver } from './ServiceResolver-D2Jz-l_Z.js';
+
+type DependencyOverrideToken = unknown;
+
+interface ClassDependencyOverride {
+    readonly token: DependencyOverrideToken;
+    readonly useClass: new (...args: never[]) => unknown;
+}
+
+type DependencyOverrideFactory = (resolver: ServiceResolver) => unknown;
+
+interface FactoryDependencyOverride {
+    readonly token: DependencyOverrideToken;
+    readonly useFactory: DependencyOverrideFactory;
+}
+
+interface ValueDependencyOverride {
+    readonly token: DependencyOverrideToken;
+    readonly useValue: unknown;
+}
+
+type DependencyOverride = ClassDependencyOverride | FactoryDependencyOverride | ValueDependencyOverride;
+
+interface DependencyInjectionOptions {
+    readonly containerBuild?: boolean;
+    readonly overrides?: readonly DependencyOverride[];
+    readonly servicesYamlPath: string;
+    readonly sourceDirectory: string;
+}
+
+declare class DependencyInjection implements ServiceResolver {
+    private readonly options;
+    private static configuredInstance;
+    private autowire;
+    private loader;
+    private readonly container;
+    private readonly overrideTokenIds;
+    static configure(options: DependencyInjectionOptions): DependencyInjection;
+    static get instance(): DependencyInjection;
+    constructor(options?: DependencyInjectionOptions);
+    private get definitions();
+    private get aliases();
+    private ensureFolderExists;
+    private getServiceClassName;
+    private getOverrideId;
+    private ensureSyntheticService;
+    private parentMatchesService;
+    private serviceIdMatchesService;
+    private serviceIdReferencesService;
+    private getReferenceId;
+    private getDefinitionArgumentReferences;
+    private findConcreteChildServiceId;
+    private findRegisteredServiceId;
+    private findAliasServiceId;
+    private findReferencedServiceIds;
+    private getOverrideTokenIds;
+    private getOverrideClassServiceId;
+    private applyClassOverride;
+    private applyFactoryOverride;
+    private applyValueOverride;
+    private applyOverrides;
+    private registerParentAliases;
+    compile(): Promise<void>;
+    getService<T>(serviceName: unknown): T;
+}
+
+type ServiceClass<T> = {
+    readonly prototype: T;
+    new (...args: never[]): T;
+};
+
+export { type ClassDependencyOverride as C, DependencyInjection as D, type FactoryDependencyOverride as F, type ServiceClass as S, type ValueDependencyOverride as V, type DependencyInjectionOptions as a, type DependencyOverride as b, type DependencyOverrideFactory as c, type DependencyOverrideToken as d };

package/dist/{Kernel-BWUOUWWI.d.cts → ShutdownHook-BjbnCKzr.d.cts}

@@ -1,10 +1,30 @@
-import { C as Consumer } from './Consumer-CC8ZRCsd.cjs';
-import { C as ConsumerMiddleware, S as ShutdownHook } from './ShutdownHook-Dib5uNKB.cjs';
-import { K as KernelLogger } from './KernelLogger-BESOFrpW.cjs';
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.cjs';
+import { D as DomainEventConsumer } from './DomainEventConsumer-Bg-bOwmh.cjs';
 import { Route } from './adapters/ui/routes/index.cjs';
-import { D as DependencyInjection, S as ServiceClass } from './ServiceClass-BmNw8fJj.cjs';
+import { b as DependencyOverride, D as DependencyInjection, S as ServiceClass } from './ServiceClass-BkEHcXDi.cjs';
 import { Initializer, Runtime } from './infrastructure/lifecycle/index.cjs';
-import { S as Scheduler } from './Scheduler-oigqNOUJ.cjs';
+import { a as Scheduler } from './Scheduler-BW-U5Ccg.cjs';
+import { K as KernelLogger } from './KernelLogger-BESOFrpW.cjs';
+
+declare abstract class Consumer {
+    private readonly consumer;
+    constructor(consumer: DomainEventConsumer);
+    private runMiddleware;
+    abstract get domainEvent(): typeof DomainEvent;
+    abstract get eventName(): string;
+    abstract get exchange(): string;
+    abstract get queueName(): string;
+    abstract handler(event: DomainEvent): Promise<void>;
+    init(): Promise<void>;
+    get<T>(service: unknown): T;
+}
+
+interface KernelDependencyInjectionOptions {
+    readonly containerBuild?: boolean;
+    readonly overrides?: readonly DependencyOverride[];
+    readonly servicesYamlPath?: string;
+    readonly sourceDirectory?: string;
+}
 
 interface KernelOptions {
     readonly di?: DependencyInjection;
@@ -29,6 +49,7 @@ declare class Kernel {
     static get consumerMiddleware(): ConsumerMiddleware[];
     static get di(): DependencyInjection;
     static get logger(): KernelLogger;
+    static get active(): Kernel;
     static get rootDirectory(): string;
     static get routes(): ServiceClass<Route>[];
     static get schedulers(): Scheduler[];
@@ -46,7 +67,8 @@ declare class Kernel {
     get logger(): KernelLogger;
     get routes(): ServiceClass<Route>[];
     get schedulers(): Scheduler[];
-    dependencyInjection(): Promise<void>;
+    private getDependencyInjectionOptions;
+    dependencyInjection(options?: KernelDependencyInjectionOptions): Promise<void>;
     getRoutes(): ServiceClass<Route>[];
     registerConsumerMiddleware(...middlewares: ConsumerMiddleware[]): void;
     registerConsumers(...ClassDefinitions: ServiceClass<Consumer>[]): void;
@@ -67,4 +89,24 @@ declare class Kernel {
 }
 declare function createKernel(options?: KernelOptions): Kernel;
 
-export { Kernel as K, type KernelOptions as a, createKernel as c };
+interface ConsumerExecutionContext {
+    readonly causationId?: string;
+    readonly correlationId?: string;
+    readonly eventId: string;
+    readonly eventName: string;
+    readonly exchange: string;
+    readonly kernel: Kernel;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly rawMessage?: unknown;
+    readonly queueName: string;
+}
+
+type ConsumerNext = () => Promise<void>;
+
+interface ConsumerMiddleware {
+    handle(event: DomainEvent, next: ConsumerNext, context: ConsumerExecutionContext): Promise<void>;
+}
+
+type ShutdownHook = () => Promise<void> | void;
+
+export { Consumer as C, Kernel as K, type ShutdownHook as S, type ConsumerExecutionContext as a, type ConsumerMiddleware as b, type ConsumerNext as c, type KernelDependencyInjectionOptions as d, type KernelOptions as e, createKernel as f };

package/dist/{Kernel-CUaqHa1s.d.ts → ShutdownHook-CMWLsfu-.d.ts}

@@ -1,10 +1,30 @@
-import { C as Consumer } from './Consumer-CeT0Wbxb.js';
-import { C as ConsumerMiddleware, S as ShutdownHook } from './ShutdownHook-BGskq2-q.js';
-import { K as KernelLogger } from './KernelLogger-BESOFrpW.js';
+import { D as DomainEvent } from './DomainEvent-mXWEtr_J.js';
+import { D as DomainEventConsumer } from './DomainEventConsumer-BroJmVty.js';
 import { Route } from './adapters/ui/routes/index.js';
-import { D as DependencyInjection, S as ServiceClass } from './ServiceClass-C7NCKdSS.js';
+import { b as DependencyOverride, D as DependencyInjection, S as ServiceClass } from './ServiceClass-Bq_fBC5R.js';
 import { Initializer, Runtime } from './infrastructure/lifecycle/index.js';
-import { S as Scheduler } from './Scheduler-oigqNOUJ.js';
+import { a as Scheduler } from './Scheduler-BW-U5Ccg.js';
+import { K as KernelLogger } from './KernelLogger-BESOFrpW.js';
+
+declare abstract class Consumer {
+    private readonly consumer;
+    constructor(consumer: DomainEventConsumer);
+    private runMiddleware;
+    abstract get domainEvent(): typeof DomainEvent;
+    abstract get eventName(): string;
+    abstract get exchange(): string;
+    abstract get queueName(): string;
+    abstract handler(event: DomainEvent): Promise<void>;
+    init(): Promise<void>;
+    get<T>(service: unknown): T;
+}
+
+interface KernelDependencyInjectionOptions {
+    readonly containerBuild?: boolean;
+    readonly overrides?: readonly DependencyOverride[];
+    readonly servicesYamlPath?: string;
+    readonly sourceDirectory?: string;
+}
 
 interface KernelOptions {
     readonly di?: DependencyInjection;
@@ -29,6 +49,7 @@ declare class Kernel {
     static get consumerMiddleware(): ConsumerMiddleware[];
     static get di(): DependencyInjection;
     static get logger(): KernelLogger;
+    static get active(): Kernel;
     static get rootDirectory(): string;
     static get routes(): ServiceClass<Route>[];
     static get schedulers(): Scheduler[];
@@ -46,7 +67,8 @@ declare class Kernel {
     get logger(): KernelLogger;
     get routes(): ServiceClass<Route>[];
     get schedulers(): Scheduler[];
-    dependencyInjection(): Promise<void>;
+    private getDependencyInjectionOptions;
+    dependencyInjection(options?: KernelDependencyInjectionOptions): Promise<void>;
     getRoutes(): ServiceClass<Route>[];
     registerConsumerMiddleware(...middlewares: ConsumerMiddleware[]): void;
     registerConsumers(...ClassDefinitions: ServiceClass<Consumer>[]): void;
@@ -67,4 +89,24 @@ declare class Kernel {
 }
 declare function createKernel(options?: KernelOptions): Kernel;
 
-export { Kernel as K, type KernelOptions as a, createKernel as c };
+interface ConsumerExecutionContext {
+    readonly causationId?: string;
+    readonly correlationId?: string;
+    readonly eventId: string;
+    readonly eventName: string;
+    readonly exchange: string;
+    readonly kernel: Kernel;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly rawMessage?: unknown;
+    readonly queueName: string;
+}
+
+type ConsumerNext = () => Promise<void>;
+
+interface ConsumerMiddleware {
+    handle(event: DomainEvent, next: ConsumerNext, context: ConsumerExecutionContext): Promise<void>;
+}
+
+type ShutdownHook = () => Promise<void> | void;
+
+export { Consumer as C, Kernel as K, type ShutdownHook as S, type ConsumerExecutionContext as a, type ConsumerMiddleware as b, type ConsumerNext as c, type KernelDependencyInjectionOptions as d, type KernelOptions as e, createKernel as f };

package/dist/Subscription-4vuAAxax.d.cts

@@ -0,0 +1,23 @@
+import { M as Message, H as HandlerContext, D as DomainEvent } from './HandlerContext-Lm89pSeG.cjs';
+import { D as DomainEvent$1 } from './DomainEvent-mXWEtr_J.cjs';
+
+type MessageHandler<TMessage extends Message = Message, TResult = unknown> = (message: TMessage, context: HandlerContext) => TResult | Promise<TResult>;
+
+interface PublishContext<TMessage extends Message | DomainEvent = Message> {
+    readonly domainEvent?: DomainEvent$1;
+    readonly message: TMessage;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly topic: string;
+}
+
+interface PublisherHook {
+    afterPublish?(context: PublishContext): Promise<void> | void;
+    beforePublish?(context: PublishContext): Promise<void> | void;
+    onPublishError?(error: unknown, context: PublishContext): Promise<void> | void;
+}
+
+interface Subscription {
+    close(): Promise<void>;
+}
+
+export type { MessageHandler as M, PublishContext as P, Subscription as S, PublisherHook as a };

package/dist/Subscription-vtF0lEHP.d.ts

@@ -0,0 +1,23 @@
+import { M as Message, H as HandlerContext, D as DomainEvent } from './HandlerContext-DUUExVo3.js';
+import { D as DomainEvent$1 } from './DomainEvent-mXWEtr_J.js';
+
+type MessageHandler<TMessage extends Message = Message, TResult = unknown> = (message: TMessage, context: HandlerContext) => TResult | Promise<TResult>;
+
+interface PublishContext<TMessage extends Message | DomainEvent = Message> {
+    readonly domainEvent?: DomainEvent$1;
+    readonly message: TMessage;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly topic: string;
+}
+
+interface PublisherHook {
+    afterPublish?(context: PublishContext): Promise<void> | void;
+    beforePublish?(context: PublishContext): Promise<void> | void;
+    onPublishError?(error: unknown, context: PublishContext): Promise<void> | void;
+}
+
+interface Subscription {
+    close(): Promise<void>;
+}
+
+export type { MessageHandler as M, PublishContext as P, Subscription as S, PublisherHook as a };