@warlock.js/herald 5.30.0 → 5.32.0

package/esm/types/connection.types.d.mts

@@ -1,9 +1,9 @@
 //#region ../../packages/herald/src/types/connection.types.d.ts
-type BaseConnectionOptions = {
+export type BaseConnectionOptions = {
   name?: string;
   isDefault?: boolean;
 };
-type RabbitMQSocketOptions = {
+export type RabbitMQSocketOptions = {
   keepAlive?: boolean | number;
   noDelay?: boolean;
   timeout?: number;
@@ -14,13 +14,13 @@ type RabbitMQSocketOptions = {
   servername?: string;
   rejectUnauthorized?: boolean;
 };
-type RabbitMQClientOptions = {
+export type RabbitMQClientOptions = {
   frameMax?: number;
   channelMax?: number;
   locale?: string;
   socket?: RabbitMQSocketOptions;
 };
-type RabbitMQConnectionOptions<TClientOptions extends RabbitMQClientOptions = RabbitMQClientOptions> = BaseConnectionOptions & {
+export type RabbitMQConnectionOptions<TClientOptions extends RabbitMQClientOptions = RabbitMQClientOptions> = BaseConnectionOptions & {
   driver: "rabbitmq";
   host?: string;
   port?: number;
@@ -35,7 +35,7 @@ type RabbitMQConnectionOptions<TClientOptions extends RabbitMQClientOptions = Ra
   prefetch?: number;
   clientOptions?: TClientOptions;
 };
-type KafkaClientOptions = {
+export type KafkaClientOptions = {
   retry?: {
     initialRetryTime?: number;
     retries?: number;
@@ -46,7 +46,7 @@ type KafkaClientOptions = {
   logLevel?: number;
   logCreator?: any;
 };
-type KafkaConnectionOptions<TClientOptions extends KafkaClientOptions = KafkaClientOptions> = BaseConnectionOptions & {
+export type KafkaConnectionOptions<TClientOptions extends KafkaClientOptions = KafkaClientOptions> = BaseConnectionOptions & {
   driver: "kafka";
   brokers: string[];
   clientId?: string;
@@ -60,8 +60,7 @@ type KafkaConnectionOptions<TClientOptions extends KafkaClientOptions = KafkaCli
   };
   clientOptions?: TClientOptions;
 };
-type ConnectionOptions = RabbitMQConnectionOptions | KafkaConnectionOptions;
-type BrokerConfigurations<TClientOptions = any> = RabbitMQConnectionOptions<TClientOptions extends RabbitMQClientOptions ? TClientOptions : RabbitMQClientOptions> | KafkaConnectionOptions<TClientOptions extends KafkaClientOptions ? TClientOptions : KafkaClientOptions>;
+export type ConnectionOptions = RabbitMQConnectionOptions | KafkaConnectionOptions;
+export type BrokerConfigurations<TClientOptions = any> = RabbitMQConnectionOptions<TClientOptions extends RabbitMQClientOptions ? TClientOptions : RabbitMQClientOptions> | KafkaConnectionOptions<TClientOptions extends KafkaClientOptions ? TClientOptions : KafkaClientOptions>;
 //#endregion
-export { BaseConnectionOptions, BrokerConfigurations, ConnectionOptions, KafkaClientOptions, KafkaConnectionOptions, RabbitMQClientOptions, RabbitMQConnectionOptions, RabbitMQSocketOptions };
 //# sourceMappingURL=connection.types.d.mts.map

package/esm/types/connection.types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"connection.types.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/types/connection.types.ts"],"mappings":";KAAY,qBAAA;EACV,IAAA;EACA,SAAS;AAAA;AAAA,KAGC,qBAAA;EACV,SAAA;EACA,OAAA;EACA,OAAA;EACA,EAAA,YAAc,MAAA,GAAS,KAAA,UAAe,MAAA;EACtC,IAAA,YAAgB,MAAA;EAChB,GAAA,YAAe,MAAA;EACf,UAAA;EACA,UAAA;EACA,kBAAA;AAAA;AAAA,KAGU,qBAAA;EACV,QAAA;EACA,UAAA;EACA,MAAA;EACA,MAAA,GAAS,qBAAqB;AAAA;AAAA,KAGpB,yBAAA,wBACa,qBAAA,GAAwB,qBAAA,IAC7C,qBAAA;EACF,MAAA;EACA,IAAA;EACA,IAAA;EACA,QAAA;EACA,QAAA;EACA,KAAA;EACA,GAAA;EACA,SAAA;EACA,iBAAA;EACA,SAAA;EACA,cAAA;EACA,QAAA;EACA,aAAA,GAAgB,cAAA;AAAA;AAAA,KAGN,kBAAA;EACV,KAAA;IACE,gBAAA;IACA,OAAA;IACA,YAAA;IACA,MAAA;IACA,UAAA;EAAA;EAEF,QAAA;EACA,UAAA;AAAA;AAAA,KAGU,sBAAA,wBAA8C,kBAAA,GAAqB,kBAAA,IAC7E,qBAAA;EACE,MAAA;EACA,OAAA;EACA,QAAA;EACA,iBAAA;EACA,cAAA;EACA,GAAA;EACA,IAAA;IACE,SAAA;IACA,QAAA;IACA,QAAA;EAAA;EAEF,aAAA,GAAgB,cAAA;AAAA;AAAA,KAGR,iBAAA,GAAoB,yBAAA,GAA4B,sBAAsB;AAAA,KAEtE,oBAAA,yBACR,yBAAA,CACE,cAAA,SAAuB,qBAAA,GAAwB,cAAA,GAAiB,qBAAA,IAElE,sBAAA,CACE,cAAA,SAAuB,kBAAA,GAAqB,cAAA,GAAiB,kBAAA"}
+{"version":3,"file":"connection.types.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/types/connection.types.ts"],"mappings":";YAAY;EACV;EACA;;YAGU;EACV;EACA;EACA;EACA,cAAc,SAAS,eAAe;EACtC,gBAAgB;EAChB,eAAe;EACf;EACA;EACA;;YAGU;EACV;EACA;EACA;EACA,SAAS;;YAGC,0BACV,uBAAuB,wBAAwB,yBAC7C;EACF;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,gBAAgB;;YAGN;EACV;IACE;IACA;IACA;IACA;IACA;;EAEF;EACA;;YAGU,uBAAuB,uBAAuB,qBAAqB,sBAC7E;EACE;EACA;EACA;EACA;EACA;EACA;EACA;IACE;IACA;IACA;;EAEF,gBAAgB;;YAGR,oBAAoB,4BAA4B;YAEhD,qBAAqB,wBAC7B,0BACE,uBAAuB,wBAAwB,iBAAiB,yBAElE,uBACE,uBAAuB,qBAAqB,iBAAiB"}

package/esm/types/driver.types.d.mts

@@ -1,13 +1,12 @@
 //#region ../../packages/herald/src/types/driver.types.d.ts
-type BrokerDriverType = "rabbitmq" | "kafka" | "redis-streams" | "sqs";
-type BrokerEvent = "connected" | "disconnected" | "error" | "reconnecting";
-type BrokerEventListener = (...args: unknown[]) => void;
-type HealthCheckResult = {
+export type BrokerDriverType = "rabbitmq" | "kafka" | "redis-streams" | "sqs";
+export type BrokerEvent = "connected" | "disconnected" | "error" | "reconnecting";
+export type BrokerEventListener = (...args: unknown[]) => void;
+export type HealthCheckResult = {
   healthy: boolean;
   latency?: number;
   error?: string;
   details?: Record<string, unknown>;
 };
 //#endregion
-export { BrokerDriverType, BrokerEvent, BrokerEventListener, HealthCheckResult };
 //# sourceMappingURL=driver.types.d.mts.map

package/esm/types/driver.types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"driver.types.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/types/driver.types.ts"],"mappings":";KAAY,gBAAA;AAAA,KAEA,WAAA;AAAA,KAEA,mBAAA,OAA0B,IAAI;AAAA,KAE9B,iBAAA;EACV,OAAA;EACA,OAAA;EACA,KAAA;EACA,OAAA,GAAU,MAAM;AAAA"}
+{"version":3,"file":"driver.types.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/types/driver.types.ts"],"mappings":";YAAY;YAEA;YAEA,0BAA0B;YAE1B;EACV;EACA;EACA;EACA,UAAU"}

package/esm/types/index.d.mts

@@ -4,4 +4,5 @@ import { BaseConnectionOptions, BrokerConfigurations, ConnectionOptions, KafkaCl
 import { BrokerDriverType, BrokerEvent, BrokerEventListener, HealthCheckResult } from "./driver.types.mjs";
 import { Message, MessageContext, MessageHandler, MessageMetadata, ResponseHandler, Subscription } from "./message.types.mjs";
 import { PublishOptions, RequestOptions } from "./publish.types.mjs";
-import { BrokerRegistryEvent, BrokerRegistryListener } from "./registry.types.mjs";
+import { BrokerRegistryEvent, BrokerRegistryListener } from "./registry.types.mjs";
+export { BaseConnectionOptions, BrokerConfigurations, BrokerDriverType, BrokerEvent, BrokerEventListener, BrokerRegistryEvent, BrokerRegistryListener, ChannelOptions, ChannelStats, ConnectionOptions, DeadLetterOptions, HealthCheckResult, KafkaClientOptions, KafkaConnectionOptions, Message, MessageContext, MessageHandler, MessageMetadata, PublishOptions, RabbitMQClientOptions, RabbitMQConnectionOptions, RabbitMQSocketOptions, RequestOptions, ResponseHandler, RetryOptions, SubscribeOptions, Subscription };

package/esm/types/message.types.d.mts

@@ -1,5 +1,5 @@
 //#region ../../packages/herald/src/types/message.types.d.ts
-type MessageMetadata = {
+export type MessageMetadata = {
   messageId: string;
   correlationId?: string;
   replyTo?: string;
@@ -9,19 +9,19 @@ type MessageMetadata = {
   retryCount?: number;
   originalChannel?: string;
 };
-type Message<TPayload = unknown> = {
+export type Message<TPayload = unknown> = {
   readonly metadata: MessageMetadata;
   readonly payload: TPayload;
   readonly raw?: unknown;
 };
-type MessageContext = {
+export type MessageContext = {
   ack(): Promise<void>;
   nack(requeue?: boolean): Promise<void>;
   reject(): Promise<void>;
   reply<T>(payload: T): Promise<void>;
   retry(delay?: number): Promise<void>;
 };
-type Subscription = {
+export type Subscription = {
   readonly id: string;
   readonly channel: string;
   readonly consumerTag?: string;
@@ -30,8 +30,7 @@ type Subscription = {
   resume(): Promise<void>;
   isActive(): boolean;
 };
-type MessageHandler<TPayload = unknown> = (message: Message<TPayload>, ctx: MessageContext) => Promise<void> | void;
-type ResponseHandler<TPayload = unknown, TResponse = unknown> = (message: Message<TPayload>, ctx: MessageContext) => Promise<TResponse> | TResponse;
+export type MessageHandler<TPayload = unknown> = (message: Message<TPayload>, ctx: MessageContext) => Promise<void> | void;
+export type ResponseHandler<TPayload = unknown, TResponse = unknown> = (message: Message<TPayload>, ctx: MessageContext) => Promise<TResponse> | TResponse;
 //#endregion
-export { Message, MessageContext, MessageHandler, MessageMetadata, ResponseHandler, Subscription };
 //# sourceMappingURL=message.types.d.mts.map

package/esm/types/message.types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"message.types.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/types/message.types.ts"],"mappings":";KAAY,eAAA;EACV,SAAA;EACA,aAAA;EACA,OAAA;EACA,QAAA;EACA,SAAA,EAAW,IAAA;EACX,OAAA,GAAU,MAAM;EAChB,UAAA;EACA,eAAA;AAAA;AAAA,KAGU,OAAA;EAAA,SACD,QAAA,EAAU,eAAA;EAAA,SACV,OAAA,EAAS,QAAQ;EAAA,SACjB,GAAA;AAAA;AAAA,KAGC,cAAA;EACV,GAAA,IAAO,OAAA;EACP,IAAA,CAAK,OAAA,aAAoB,OAAA;EACzB,MAAA,IAAU,OAAA;EACV,KAAA,IAAS,OAAA,EAAS,CAAA,GAAI,OAAA;EACtB,KAAA,CAAM,KAAA,YAAiB,OAAA;AAAA;AAAA,KAGb,YAAA;EAAA,SACD,EAAA;EAAA,SACA,OAAA;EAAA,SACA,WAAA;EACT,WAAA,IAAe,OAAA;EACf,KAAA,IAAS,OAAA;EACT,MAAA,IAAU,OAAA;EACV,QAAA;AAAA;AAAA,KAGU,cAAA,wBACV,OAAA,EAAS,OAAA,CAAQ,QAAA,GACjB,GAAA,EAAK,cAAA,KACF,OAAA;AAAA,KAEO,eAAA,6CACV,OAAA,EAAS,OAAA,CAAQ,QAAA,GACjB,GAAA,EAAK,cAAA,KACF,OAAA,CAAQ,SAAA,IAAa,SAAA"}
+{"version":3,"file":"message.types.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/types/message.types.ts"],"mappings":";YAAY;EACV;EACA;EACA;EACA;EACA,WAAW;EACX,UAAU;EACV;EACA;;YAGU,QAAQ;WACT,UAAU;WACV,SAAS;WACT;;YAGC;EACV,OAAO;EACP,KAAK,oBAAoB;EACzB,UAAU;EACV,MAAM,GAAG,SAAS,IAAI;EACtB,MAAM,iBAAiB;;YAGb;WACD;WACA;WACA;EACT,eAAe;EACf,SAAS;EACT,UAAU;EACV;;YAGU,eAAe,uBACzB,SAAS,QAAQ,WACjB,KAAK,mBACF;YAEO,gBAAgB,oBAAoB,wBAC9C,SAAS,QAAQ,WACjB,KAAK,mBACF,QAAQ,aAAa"}

package/esm/types/publish.types.d.mts

@@ -1,5 +1,5 @@
 //#region ../../packages/herald/src/types/publish.types.d.ts
-type PublishOptions = {
+export type PublishOptions = {
   priority?: number;
   ttl?: number;
   delay?: number;
@@ -8,9 +8,8 @@ type PublishOptions = {
   correlationId?: string;
   expiration?: number;
 };
-type RequestOptions = PublishOptions & {
+export type RequestOptions = PublishOptions & {
   timeout?: number;
 };
 //#endregion
-export { PublishOptions, RequestOptions };
 //# sourceMappingURL=publish.types.d.mts.map

package/esm/types/publish.types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"publish.types.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/types/publish.types.ts"],"mappings":";KAAY,cAAA;EACV,QAAA;EACA,GAAA;EACA,KAAA;EACA,OAAA,GAAU,MAAM;EAChB,UAAA;EACA,aAAA;EACA,UAAA;AAAA;AAAA,KAGU,cAAA,GAAiB,cAAc;EACzC,OAAO;AAAA"}
+{"version":3,"file":"publish.types.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/types/publish.types.ts"],"mappings":";YAAY;EACV;EACA;EACA;EACA,UAAU;EACV;EACA;EACA;;YAGU,iBAAiB;EAC3B"}

package/esm/types/registry.types.d.mts

@@ -1,8 +1,6 @@
 import { Broker } from "../communicators/broker.mjs";
-
 //#region ../../packages/herald/src/types/registry.types.d.ts
-type BrokerRegistryEvent = "registered" | "default-registered" | "connected" | "disconnected";
-type BrokerRegistryListener = (broker: Broker) => void;
+export type BrokerRegistryEvent = "registered" | "default-registered" | "connected" | "disconnected";
+export type BrokerRegistryListener = (broker: Broker) => void;
 //#endregion
-export { BrokerRegistryEvent, BrokerRegistryListener };
 //# sourceMappingURL=registry.types.d.mts.map

package/esm/types/registry.types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.types.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/types/registry.types.ts"],"mappings":";;;KAEY,mBAAA;AAAA,KAMA,sBAAA,IAA0B,MAAc,EAAN,MAAM"}
+{"version":3,"file":"registry.types.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/types/registry.types.ts"],"mappings":";;YAEY;YAMA,0BAA0B,QAAQ"}

package/esm/types/subscribe.types.d.mts

@@ -1,13 +1,13 @@
 //#region ../../packages/herald/src/types/subscribe.types.d.ts
-type RetryOptions = {
+export type RetryOptions = {
   maxRetries: number;
   delay: number | ((attempt: number) => number);
 };
-type DeadLetterOptions = {
+export type DeadLetterOptions = {
   channel: string;
   preserveOriginal?: boolean;
 };
-type SubscribeOptions = {
+export type SubscribeOptions = {
   consumerId?: string;
   group?: string;
   prefetch?: number;
@@ -17,5 +17,4 @@ type SubscribeOptions = {
   exclusive?: boolean;
 };
 //#endregion
-export { DeadLetterOptions, RetryOptions, SubscribeOptions };
 //# sourceMappingURL=subscribe.types.d.mts.map

package/esm/types/subscribe.types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"subscribe.types.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/types/subscribe.types.ts"],"mappings":";KAAY,YAAA;EACV,UAAA;EACA,KAAA,aAAkB,OAAA;AAAA;AAAA,KAGR,iBAAA;EACV,OAAA;EACA,gBAAgB;AAAA;AAAA,KAGN,gBAAA;EACV,UAAA;EACA,KAAA;EACA,QAAA;EACA,OAAA;EACA,KAAA,GAAQ,YAAA;EACR,UAAA,GAAa,iBAAiB;EAC9B,SAAA;AAAA"}
+{"version":3,"file":"subscribe.types.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/types/subscribe.types.ts"],"mappings":";YAAY;EACV;EACA,kBAAkB;;YAGR;EACV;EACA;;YAGU;EACV;EACA;EACA;EACA;EACA,QAAQ;EACR,aAAa;EACb"}

package/esm/use-case-broadcast.d.mts

@@ -6,7 +6,7 @@
  * takes no dependency on `@warlock.js/core`. The shape only needs the fields the
  * adapter reads (`event` for the channel, `payload` for the body).
  */
-type UseCaseBroadcastEvent = {
+export type UseCaseBroadcastEvent = {
   useCase: string;
   event: string;
   id: string;
@@ -31,11 +31,10 @@ type UseCaseBroadcastEvent = {
  *
  * @param options - Optional broker name (defaults to the default broker)
  */
-declare function heraldBroadcast(options?: {
+export declare function heraldBroadcast(options?: {
   broker?: string;
 }): {
   broadcast(event: UseCaseBroadcastEvent): Promise<void>;
 };
 //#endregion
-export { UseCaseBroadcastEvent, heraldBroadcast };
 //# sourceMappingURL=use-case-broadcast.d.mts.map

package/esm/use-case-broadcast.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"use-case-broadcast.d.mts","names":[],"sources":["../../../../../../../packages/herald/src/use-case-broadcast.ts"],"mappings":";;AASA;;;;;;KAAY,qBAAA;EACV,OAAA;EACA,KAAA;EACA,EAAA;EACA,EAAA,EAAI,IAAI;EACR,OAAA;AAAA;;;;;;;;;;;AAuBwD;;;;;;;;iBAF1C,eAAA,CAAgB,OAAA;EAAY,MAAA;AAAA;mBAEjB,qBAAA,GAAwB,OAAO;AAAA"}
+{"version":3,"file":"use-case-broadcast.d.mts","names":[],"sources":["../../../../../../../packages/herald/src/use-case-broadcast.ts"],"mappings":";;;;;;;;YASY;EACV;EACA;EACA;EACA,IAAI;EACJ;;;;;;;;;;;;;;;;;;;;wBAqBc,gBAAgB;EAAY;;EAElC,UAAS,OAAQ,wBAAwB"}

package/esm/utils/connect-to-broker.d.mts

@@ -3,7 +3,11 @@ import { ConnectionOptions } from "../types/connection.types.mjs";
 import { ChannelContract } from "../contracts/channel.contract.mjs";
 import { EventMessage } from "../message-managers/event-message.mjs";
 import { EventConsumerClass } from "../message-managers/types.mjs";
+import "../contracts/index.mjs";
 import { Broker } from "../communicators/broker.mjs";
+import "../types/index.mjs";
+import "../communicators/index.mjs";
+import "../message-managers/index.mjs";
 //#region ../../packages/herald/src/utils/connect-to-broker.d.ts
 /**
  * Connect to a message broker and register it.
@@ -58,7 +62,7 @@ import { Broker } from "../communicators/broker.mjs";
  * herald("analytics").channel("events").publish({ ... });
  * ```
  */
-declare function connectToBroker(options: ConnectionOptions): Promise<Broker>;
+export declare function connectToBroker(options: ConnectionOptions): Promise<Broker>;
 /**
  * Get a broker by name or the default one.
  *
@@ -87,7 +91,7 @@ declare function connectToBroker(options: ConnectionOptions): Promise<Broker>;
  *   });
  * ```
  */
-declare function herald(name?: string): Broker;
+export declare function herald(name?: string): Broker;
 /**
  * Get channel instance for the given name from default broker.
  *
@@ -104,7 +108,7 @@ declare function herald(name?: string): Broker;
  * await channel.publish({ userId: 1 });
  * ```
  */
-declare function heraldChannel<TPayload = unknown>(name: string, options?: ChannelOptions<TPayload>): ChannelContract<TPayload>;
+export declare function heraldChannel<TPayload = unknown>(name: string, options?: ChannelOptions<TPayload>): ChannelContract<TPayload>;
 /**
  * Publish an EventMessage to the default broker.
  *
@@ -117,7 +121,7 @@ declare function heraldChannel<TPayload = unknown>(name: string, options?: Chann
  * await publishEvent(new UserUpdatedEvent({ id: 1, name: "John Doe" }));
  * ```
  */
-declare function publishEvent<TPayload = Record<string, any>>(event: EventMessage<TPayload>): Promise<void>;
+export declare function publishEvent<TPayload = Record<string, any>>(event: EventMessage<TPayload>): Promise<void>;
 /**
  * Subscribe an EventConsumer class to the default broker.
  *
@@ -130,7 +134,6 @@ declare function publishEvent<TPayload = Record<string, any>>(event: EventMessag
  * await subscribeConsumer(UserUpdatedConsumer);
  * ```
  */
-declare function subscribeConsumer<TPayload = Record<string, any>>(Consumer: EventConsumerClass<TPayload>): Promise<() => void>;
+export declare function subscribeConsumer<TPayload = Record<string, any>>(Consumer: EventConsumerClass<TPayload>): Promise<() => void>;
 //#endregion
-export { connectToBroker, herald, heraldChannel, publishEvent, subscribeConsumer };
 //# sourceMappingURL=connect-to-broker.d.mts.map

package/esm/utils/connect-to-broker.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"connect-to-broker.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/utils/connect-to-broker.ts"],"mappings":";;;;;;;;;;;;;;;AA0DA;;;;;;;;;;;;;AAAiF;AA6EjF;;;;AAA6C;AAoB7C;;;;;;;;;;;;;;;;;AAG2B;AAgB3B;;;;;;;;iBApHsB,eAAA,CAAgB,OAAA,EAAS,iBAAA,GAAoB,OAAA,CAAQ,MAAA;;;;;;;;AAoHqB;AAgBhG;;;;;;;;;;;;;;;;AACwC;;;;iBAxDxB,MAAA,CAAO,IAAA,YAAgB,MAAM;;;;;;;;;;;;;;;;;iBAoB7B,aAAA,qBACd,IAAA,UACA,OAAA,GAAU,cAAA,CAAe,QAAA,IACxB,eAAA,CAAgB,QAAA;;;;;;;;;;;;;iBAgBG,YAAA,YAAwB,MAAA,eAAqB,KAAA,EAAO,YAAA,CAAa,QAAA,IAAS,OAAA;;;;;;;;;;;;;iBAgB1E,iBAAA,YAA6B,MAAA,eACjD,QAAA,EAAU,kBAAA,CAAmB,QAAA,IAAS,OAAA"}
+{"version":3,"file":"connect-to-broker.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/utils/connect-to-broker.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA0DsB,gBAAgB,SAAS,oBAAoB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6E3D,OAAO,gBAAgB;;;;;;;;;;;;;;;;;wBAoBvB,cAAc,oBAC5B,cACA,UAAU,eAAe,YACxB,gBAAgB;;;;;;;;;;;;;wBAgBG,aAAa,WAAW,qBAAqB,OAAO,aAAa,YAAS;;;;;;;;;;;;;wBAgB1E,kBAAkB,WAAW,qBACjD,UAAU,mBAAmB,YAAS"}

package/esm/utils/index.d.mts

@@ -1 +1,2 @@
-import { connectToBroker, herald, heraldChannel, publishEvent, subscribeConsumer } from "./connect-to-broker.mjs";
+import { connectToBroker, herald, heraldChannel, publishEvent, subscribeConsumer } from "./connect-to-broker.mjs";
+export { connectToBroker, herald, heraldChannel, publishEvent, subscribeConsumer };

package/esm/utils/index.mjs

@@ -1,3 +1,3 @@
 import { connectToBroker, herald, heraldChannel, publishEvent, subscribeConsumer } from "./connect-to-broker.mjs";
 
-export {  };
+export { connectToBroker, herald, heraldChannel, publishEvent, subscribeConsumer };

package/llms-full.txt

@@ -25,9 +25,9 @@ herald()
   .subscribe(async (message, ctx) => {
     try {
       await sendWelcomeEmail(message.payload.email);
-      await ctx.ack();          // success — message removed from queue
+      await ctx.ack(); // success — message removed from queue
     } catch (error) {
-      await ctx.nack(true);     // failure — requeue for redelivery
+      await ctx.nack(true); // failure — requeue for redelivery
     }
   });
 ```
@@ -38,7 +38,7 @@ herald()
 - Handler **throws** → herald **auto-nacks** (requeue, or DLQ/reject once retries are exhausted — see below).
 - Handler calls `ctx.ack()` / `ctx.nack()` / `ctx.reject()` / `ctx.retry()` → herald respects that and does nothing further.
 
-So the `try/catch` above is optional — letting the error throw produces the same auto-nack. Call `ctx` methods explicitly only when you want a *non-default* outcome (reject without requeue, route to DLQ, delayed retry). The one mode that loses messages is `autoAck: true`, where the broker acks on delivery before your handler runs.
+So the `try/catch` above is optional — letting the error throw produces the same auto-nack. Call `ctx` methods explicitly only when you want a _non-default_ outcome (reject without requeue, route to DLQ, delayed retry). The one mode that loses messages is `autoAck: true`, where the broker acks on delivery before your handler runs.
 
 ## Message context — flow control
 
@@ -52,23 +52,23 @@ ctx.reply(payload);     // for request-response pattern (see request-and-respond
 
 Pick by intent:
 
-| Intent | Use |
-| --- | --- |
-| Processed cleanly | `ctx.ack()` |
-| Transient failure, try again | `ctx.nack(true)` or `ctx.retry(5000)` |
-| Permanent failure, send to DLQ | `ctx.nack(false)` or `ctx.reject()` |
-| Validation failure (bad message) | `ctx.reject()` — don't requeue |
+| Intent                           | Use                                   |
+| -------------------------------- | ------------------------------------- |
+| Processed cleanly                | `ctx.ack()`                           |
+| Transient failure, try again     | `ctx.nack(true)` or `ctx.retry(5000)` |
+| Permanent failure, send to DLQ   | `ctx.nack(false)` or `ctx.reject()`   |
+| Validation failure (bad message) | `ctx.reject()` — don't requeue        |
 
 ## Subscribe options
 
 ```ts
 await channel.subscribe(handler, {
-  group: "email-workers",      // consumer group / tag — multiple consumers share work
-  prefetch: 10,                 // concurrency — how many in-flight messages this consumer holds
-  autoAck: false,               // default; keep it false in production
-  exclusive: false,             // single consumer only on this channel?
+  group: "email-workers", // consumer group / tag — multiple consumers share work
+  prefetch: 10, // concurrency — how many in-flight messages this consumer holds
+  autoAck: false, // default; keep it false in production
+  exclusive: false, // single consumer only on this channel?
   retry: {
-    maxRetries: 3,              // redelivery ceiling on handler throw (delay not auto-applied — see below)
+    maxRetries: 3, // redelivery ceiling on handler throw (delay not auto-applied — see below)
     delay: 1000,
   },
   deadLetter: {
@@ -109,10 +109,12 @@ The DLQ always forwards the full original payload plus the message metadata, so
 Messages that exhausted retries land in `user.created.failed`. Subscribe to it separately for alerting / manual inspection:
 
 ```ts
-herald().channel("user.created.failed").subscribe(async (message, ctx) => {
-  await alerts.notify(`Failed: ${JSON.stringify(message.payload)}`);
-  await ctx.ack();
-});
+herald()
+  .channel("user.created.failed")
+  .subscribe(async (message, ctx) => {
+    await alerts.notify(`Failed: ${JSON.stringify(message.payload)}`);
+    await ctx.ack();
+  });
 ```
 
 ## Decorator-style consumers — `@Consumable` + `EventConsumer`
@@ -123,7 +125,7 @@ For class-based consumers that pair with the `EventMessage` (the `publish-messag
 import { Consumable, EventConsumer } from "@warlock.js/herald";
 import type { ConsumedEventMessage } from "@warlock.js/herald";
 
-@Consumable()  // or @Consumable({ broker: "analytics" }) to target a non-default broker
+@Consumable() // or @Consumable({ broker: "analytics" }) to target a non-default broker
 export class UserCreatedConsumer extends EventConsumer<{ id: number; email: string }> {
   public static eventName = "user.created";
 
@@ -175,7 +177,7 @@ export class UserCreatedConsumer extends EventConsumer {
 import { defineConsumer } from "@warlock.js/herald";
 
 export const userCreatedConsumer = defineConsumer<{ id: number; email: string }>("user.created", {
-  schema: userCreatedSchema,                 // optional seal validation
+  schema: userCreatedSchema, // optional seal validation
   handle: async (payload, event) => {
     await sendWelcomeEmail(payload.email);
   },
@@ -191,11 +193,11 @@ export const userCreatedConsumer = defineConsumer<{ id: number; email: string }>
 ```ts
 const subscription = await channel.subscribe(handler);
 
-subscription.id;            // the consumer id (string)
-subscription.isActive();    // boolean
+subscription.id; // the consumer id (string)
+subscription.isActive(); // boolean
 
-await subscription.unsubscribe();   // cancel the consumer on the broker
-await subscription.pause();          // also cancels the consumer (RabbitMQ has no native pause)
+await subscription.unsubscribe(); // cancel the consumer on the broker
+await subscription.pause(); // also cancels the consumer (RabbitMQ has no native pause)
 ```
 
 On the RabbitMQ driver, `pause()` and `unsubscribe()` both cancel the consumer; `resume()` is **not supported and throws** — create a fresh subscription to start consuming again. You can also cancel by id from the channel: `await channel.unsubscribeById(consumerId)`, or drop every consumer on the channel with `await channel.stopConsuming()`.
@@ -206,10 +208,10 @@ The channel exposes queue-management helpers beyond pub/sub:
 
 ```ts
 const { messageCount, consumerCount } = await channel.stats(); // queue depth + live consumers
-const purged = await channel.purge();    // drop all pending messages, returns the count
-const ok = await channel.exists();        // does the queue exist on the broker?
-await channel.assert();                   // create the queue with its options (idempotent)
-await channel.delete();                   // remove the queue entirely
+const purged = await channel.purge(); // drop all pending messages, returns the count
+const ok = await channel.exists(); // does the queue exist on the broker?
+await channel.assert(); // create the queue with its options (idempotent)
+await channel.delete(); // remove the queue entirely
 ```
 
 `assert()` runs lazily on the first `publish` / `subscribe`, so you rarely call it directly — reach for it only to pre-create a queue before any traffic.
@@ -304,20 +306,20 @@ await connectToBroker({
   host: process.env.ANALYTICS_HOST,
 });
 
-herald().channel("emails").publish({ /* ... */ });           // → notifications
-herald("analytics").channel("events").publish({ /* ... */ }); // → analytics
+herald().channel("emails").publish({/* ... */}); // → notifications
+herald("analytics").channel("events").publish({/* ... */}); // → analytics
 ```
 
 `connectToBroker` defaults `isDefault` to `true`, and the registry promotes the most-recently-registered default. So when you register more than one broker, mark the secondaries `isDefault: false` — otherwise the last one wins and `herald()` returns the wrong broker.
 
 ## Pick a skill
 
-| If the task is about… | Load |
-| --- | --- |
-| Publishing messages — single + batch + publish options (priority, ttl, delay, persistent, headers) | the `publish-message` topic |
-| Subscribing to messages — handler signature, message context (ack/nack/retry), prefetch, retry policy, dead-letter | the `consume-message` topic |
-| Request/response (RPC) — `channel.request(...)` + `channel.respond(...)` for synchronous-style calls over a message bus | the `request-and-respond` topic |
-| Schema-validated channels — `.channel(name, { schema })` with `@warlock.js/seal` | See the `seal-basics` topic of the `warlock-js-seal` skill + skills below |
+| If the task is about…                                                                                                   | Load                                                                      |
+| ----------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- |
+| Publishing messages — single + batch + publish options (priority, ttl, delay, persistent, headers)                      | the `publish-message` topic                                               |
+| Subscribing to messages — handler signature, message context (ack/nack/retry), prefetch, retry policy, dead-letter      | the `consume-message` topic                                               |
+| Request/response (RPC) — `channel.request(...)` + `channel.respond(...)` for synchronous-style calls over a message bus | the `request-and-respond` topic                                           |
+| Schema-validated channels — `.channel(name, { schema })` with `@warlock.js/seal`                                        | See the `seal-basics` topic of the `warlock-js-seal` skill + skills below |
 
 ## Things NOT to do
 
@@ -363,8 +365,8 @@ type UserPayload = { userId: number; email: string };
 
 const channel = herald().channel<UserPayload>("user.created");
 
-await channel.publish({ userId: 1, email: "test@example.com" });   // ✅ typed
-await channel.publish({ userId: "1" } as never);                    // ❌ compile error
+await channel.publish({ userId: 1, email: "test@example.com" }); // ✅ typed
+await channel.publish({ userId: "1" } as never); // ❌ compile error
 ```
 
 Share the payload type between producer and consumer via a common `types/` file.
@@ -381,7 +383,7 @@ const userSchema = v.object({
 
 const channel = herald().channel("user.created", { schema: userSchema });
 
-await channel.publish({ userId: 1, email: "invalid" });   // Throws — fails .email()
+await channel.publish({ userId: 1, email: "invalid" }); // Throws — fails .email()
 ```
 
 The schema runs `validate()` before the message hits the broker. Invalid payloads never leave the producer. See the `seal-basics` topic of the `warlock-js-seal` skill.
@@ -390,10 +392,10 @@ The schema runs `validate()` before the message hits the broker. Invalid payload
 
 ```ts
 await channel.publish(payload, {
-  priority: 5,           // 0-9, higher = served first
-  expiration: 60_000,    // ms — message expires if not consumed (RabbitMQ uses `expiration`, not `ttl`)
-  delay: 5_000,          // ms — delayed delivery (requires RabbitMQ delay plugin)
-  persistent: true,      // survive broker restart (default true)
+  priority: 5, // 0-9, higher = served first
+  expiration: 60_000, // ms — message expires if not consumed (RabbitMQ uses `expiration`, not `ttl`)
+  delay: 5_000, // ms — delayed delivery (requires RabbitMQ delay plugin)
+  persistent: true, // survive broker restart (default true)
   correlationId: "uuid", // for tracking across services
   headers: {
     tenantId: "42",
@@ -407,14 +409,17 @@ The headers field is free-form — consumers read `message.metadata.headers?.ten
 ## Batch publishing
 
 ```ts
-await channel.publishBatch([
-  { userId: 1, email: "a@example.com" },
-  { userId: 2, email: "b@example.com" },
-  { userId: 3, email: "c@example.com" },
-], {
-  // Options apply to every message in the batch
-  persistent: true,
-});
+await channel.publishBatch(
+  [
+    { userId: 1, email: "a@example.com" },
+    { userId: 2, email: "b@example.com" },
+    { userId: 3, email: "c@example.com" },
+  ],
+  {
+    // Options apply to every message in the batch
+    persistent: true,
+  },
+);
 ```
 
 Under the hood `publishBatch` iterates and calls `.publish()` per message — there's no AMQP-level batching today. It's an ergonomic shape for "emit these N items" (bulk import, fanout to many recipients), not a throughput optimization. The same `options` apply to every message.
@@ -464,7 +469,7 @@ export default {
 ```ts
 // The use case opts in — channel name defaults to the use case name.
 export const createUserUseCase = useCase({
-  name: "users.create",      // → publishes to channel "users.create"
+  name: "users.create", // → publishes to channel "users.create"
   schema: createUserSchema,
   handler: async (data) => User.create(data),
   broadcast: true,
@@ -548,12 +553,12 @@ The promise rejects if no reply arrives within `timeout` ms. Pick a sane number
 
 ## When to use it vs HTTP
 
-| Use HTTP | Use request/respond |
-| --- | --- |
+| Use HTTP                        | Use request/respond                         |
+| ------------------------------- | ------------------------------------------- |
 | Stateless, fast, idempotent ops | Slow / queued ops where the caller can wait |
-| Public API surface | Internal service-to-service |
-| Frontend consumption | Backend orchestration |
-| Synchronous user-facing flow | Async-but-needs-result patterns |
+| Public API surface              | Internal service-to-service                 |
+| Frontend consumption            | Backend orchestration                       |
+| Synchronous user-facing flow    | Async-but-needs-result patterns             |
 
 The bus adds queue persistence and retry. HTTP is faster for sub-100ms ops; the bus shines when the operation has variable duration or needs a queue's backpressure.
 

package/package.json

@@ -8,8 +8,8 @@
     "@mongez/copper": "^2.1.3",
     "@mongez/events": "^2.2.8",
     "@mongez/reinforcements": "^4.0.2",
-    "@warlock.js/logger": "5.30.0",
-    "@warlock.js/seal": "5.30.0"
+    "@warlock.js/logger": "5.32.0",
+    "@warlock.js/seal": "5.32.0"
   },
   "repository": {
     "type": "git",
@@ -37,7 +37,7 @@
   ],
   "author": "hassanzohdy",
   "license": "MIT",
-  "version": "5.30.0",
+  "version": "5.32.0",
   "main": "./cjs/index.cjs",
   "module": "./esm/index.mjs",
   "types": "./esm/index.d.mts",