@warlock.js/herald 5.29.0 → 5.31.0

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

@@ -1 +1 @@
-{"version":3,"file":"channel.types.d.mts","names":[],"sources":["../../../../../../../herald/src/types/channel.types.ts"],"mappings":";;;;KAGY,cAAA;EACV,IAAA;EACA,OAAA;EACA,UAAA;EACA,SAAA;EACA,UAAA,GAAa,iBAAA;EACb,cAAA;EACA,UAAA;EACA,SAAA;EACA,MAAA,GAAS,aAAa;AAAA;AAAA,KAGZ,YAAA;EACV,YAAA;EACA,aAAA;EACA,IAAA;AAAA"}
+{"version":3,"file":"channel.types.d.mts","names":[],"sources":["../../../../../../../../packages/herald/src/types/channel.types.ts"],"mappings":";;;;KAGY,cAAA;EACV,IAAA;EACA,OAAA;EACA,UAAA;EACA,SAAA;EACA,UAAA,GAAa,iBAAA;EACb,cAAA;EACA,UAAA;EACA,SAAA;EACA,MAAA,GAAS,aAAa;AAAA;AAAA,KAGZ,YAAA;EACV,YAAA;EACA,aAAA;EACA,IAAA;AAAA"}

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

@@ -1,4 +1,4 @@
-//#region ../herald/src/types/connection.types.d.ts
+//#region ../../packages/herald/src/types/connection.types.d.ts
 type BaseConnectionOptions = {
   name?: string;
   isDefault?: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"connection.types.d.mts","names":[],"sources":["../../../../../../../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":";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"}

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

@@ -1,4 +1,4 @@
-//#region ../herald/src/types/driver.types.d.ts
+//#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;

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

@@ -1 +1 @@
-{"version":3,"file":"driver.types.d.mts","names":[],"sources":["../../../../../../../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":";KAAY,gBAAA;AAAA,KAEA,WAAA;AAAA,KAEA,mBAAA,OAA0B,IAAI;AAAA,KAE9B,iBAAA;EACV,OAAA;EACA,OAAA;EACA,KAAA;EACA,OAAA,GAAU,MAAM;AAAA"}

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

@@ -1,4 +1,4 @@
-//#region ../herald/src/types/message.types.d.ts
+//#region ../../packages/herald/src/types/message.types.d.ts
 type MessageMetadata = {
   messageId: string;
   correlationId?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"message.types.d.mts","names":[],"sources":["../../../../../../../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":";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"}

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

@@ -1,4 +1,4 @@
-//#region ../herald/src/types/publish.types.d.ts
+//#region ../../packages/herald/src/types/publish.types.d.ts
 type PublishOptions = {
   priority?: number;
   ttl?: number;

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

@@ -1 +1 @@
-{"version":3,"file":"publish.types.d.mts","names":[],"sources":["../../../../../../../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":";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"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"registry.types.d.mts","names":[],"sources":["../../../../../../../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":";;;KAEY,mBAAA;AAAA,KAMA,sBAAA,IAA0B,MAAc,EAAN,MAAM"}

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

@@ -1,4 +1,4 @@
-//#region ../herald/src/types/subscribe.types.d.ts
+//#region ../../packages/herald/src/types/subscribe.types.d.ts
 type RetryOptions = {
   maxRetries: number;
   delay: number | ((attempt: number) => number);

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

@@ -1 +1 @@
-{"version":3,"file":"subscribe.types.d.mts","names":[],"sources":["../../../../../../../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":";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"}

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

@@ -1,4 +1,4 @@
-//#region ../herald/src/use-case-broadcast.d.ts
+//#region ../../packages/herald/src/use-case-broadcast.d.ts
 /**
  * Minimal mirror of `@warlock.js/core`'s `UseCaseBroadcastEvent`.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"use-case-broadcast.d.mts","names":[],"sources":["../../../../../../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":";;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"}

package/esm/use-case-broadcast.mjs

@@ -1,6 +1,6 @@
 import { herald } from "./utils/connect-to-broker.mjs";
 
-//#region ../herald/src/use-case-broadcast.ts
+//#region ../../packages/herald/src/use-case-broadcast.ts
 /**
 * Channel adapter that publishes use-case broadcast events onto a herald broker.
 *

package/esm/use-case-broadcast.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-case-broadcast.mjs","names":[],"sources":["../../../../../../herald/src/use-case-broadcast.ts"],"sourcesContent":["import { herald } from \"./utils/connect-to-broker\";\n\n/**\n * Minimal mirror of `@warlock.js/core`'s `UseCaseBroadcastEvent`.\n *\n * Kept local on purpose: this adapter is **structurally typed** so `@warlock.js/herald`\n * takes no dependency on `@warlock.js/core`. The shape only needs the fields the\n * adapter reads (`event` for the channel, `payload` for the body).\n */\nexport type UseCaseBroadcastEvent = {\n  useCase: string;\n  event: string;\n  id: string;\n  at: Date;\n  payload: unknown;\n};\n\n/**\n * Channel adapter that publishes use-case broadcast events onto a herald broker.\n *\n * Register it in the use-cases config so successful use cases fan out to the bus:\n *\n * @example\n * // src/config/use-cases.ts\n * import { heraldBroadcast } from \"@warlock.js/herald\";\n *\n * export default {\n *   broadcast: {\n *     enabled: true,\n *     channels: [heraldBroadcast({ broker: \"default\" })],\n *   },\n * } satisfies UseCaseConfigurations;\n *\n * @param options - Optional broker name (defaults to the default broker)\n */\nexport function heraldBroadcast(options?: { broker?: string }) {\n  return {\n    async broadcast(event: UseCaseBroadcastEvent): Promise<void> {\n      await herald(options?.broker).channel(event.event).publish(event.payload);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,gBAAgB,SAA+B;CAC7D,OAAO,EACL,MAAM,UAAU,OAA6C;EAC3D,MAAM,OAAO,SAAS,MAAM,CAAC,CAAC,QAAQ,MAAM,KAAK,CAAC,CAAC,QAAQ,MAAM,OAAO;CAC1E,EACF;AACF"}
+{"version":3,"file":"use-case-broadcast.mjs","names":[],"sources":["../../../../../../../packages/herald/src/use-case-broadcast.ts"],"sourcesContent":["import { herald } from \"./utils/connect-to-broker\";\n\n/**\n * Minimal mirror of `@warlock.js/core`'s `UseCaseBroadcastEvent`.\n *\n * Kept local on purpose: this adapter is **structurally typed** so `@warlock.js/herald`\n * takes no dependency on `@warlock.js/core`. The shape only needs the fields the\n * adapter reads (`event` for the channel, `payload` for the body).\n */\nexport type UseCaseBroadcastEvent = {\n  useCase: string;\n  event: string;\n  id: string;\n  at: Date;\n  payload: unknown;\n};\n\n/**\n * Channel adapter that publishes use-case broadcast events onto a herald broker.\n *\n * Register it in the use-cases config so successful use cases fan out to the bus:\n *\n * @example\n * // src/config/use-cases.ts\n * import { heraldBroadcast } from \"@warlock.js/herald\";\n *\n * export default {\n *   broadcast: {\n *     enabled: true,\n *     channels: [heraldBroadcast({ broker: \"default\" })],\n *   },\n * } satisfies UseCaseConfigurations;\n *\n * @param options - Optional broker name (defaults to the default broker)\n */\nexport function heraldBroadcast(options?: { broker?: string }) {\n  return {\n    async broadcast(event: UseCaseBroadcastEvent): Promise<void> {\n      await herald(options?.broker).channel(event.event).publish(event.payload);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,gBAAgB,SAA+B;CAC7D,OAAO,EACL,MAAM,UAAU,OAA6C;EAC3D,MAAM,OAAO,SAAS,MAAM,CAAC,CAAC,QAAQ,MAAM,KAAK,CAAC,CAAC,QAAQ,MAAM,OAAO;CAC1E,EACF;AACF"}

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

@@ -4,7 +4,7 @@ import { ChannelContract } from "../contracts/channel.contract.mjs";
 import { EventMessage } from "../message-managers/event-message.mjs";
 import { EventConsumerClass } from "../message-managers/types.mjs";
 import { Broker } from "../communicators/broker.mjs";
-//#region ../herald/src/utils/connect-to-broker.d.ts
+//#region ../../packages/herald/src/utils/connect-to-broker.d.ts
 /**
  * Connect to a message broker and register it.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"connect-to-broker.d.mts","names":[],"sources":["../../../../../../../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":";;;;;;;;;;;;;;;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"}

package/esm/utils/connect-to-broker.mjs

@@ -1,7 +1,7 @@
 import { brokerRegistry } from "../communicators/broker-registry.mjs";
 import "../communicators/index.mjs";
 
-//#region ../herald/src/utils/connect-to-broker.ts
+//#region ../../packages/herald/src/utils/connect-to-broker.ts
 /**
 * Connect to a message broker and register it.
 *

package/esm/utils/connect-to-broker.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"connect-to-broker.mjs","names":[],"sources":["../../../../../../../herald/src/utils/connect-to-broker.ts"],"sourcesContent":["import { Broker, brokerRegistry } from \"../communicators\";\nimport type { BrokerDriverContract, ChannelContract } from \"../contracts\";\nimport { type EventConsumerClass, EventMessage } from \"../message-managers\";\nimport type { ChannelOptions, ConnectionOptions, RabbitMQConnectionOptions } from \"../types\";\n\n/**\n * Connect to a message broker and register it.\n *\n * This is a high-level utility function that simplifies connection setup\n * for most projects. It handles driver instantiation, connection,\n * broker creation, and automatic registration.\n *\n * **Supported Drivers:**\n * - `rabbitmq` (default) - RabbitMQ/AMQP driver\n * - `kafka` - Apache Kafka driver (coming soon)\n *\n * @param options - Connection configuration options\n * @returns A connected and registered Broker instance\n * @throws {Error} If connection fails or driver is not implemented\n *\n * @example\n * ```typescript\n * // RabbitMQ connection\n * const broker = await connectToBroker({\n *   driver: \"rabbitmq\",\n *   host: \"localhost\",\n *   port: 5672,\n *   username: \"guest\",\n *   password: \"guest\",\n * });\n *\n * // Use the broker\n * await broker.channel(\"user.created\").publish({ userId: 1 });\n * ```\n *\n * @example\n * ```typescript\n * // Multiple brokers\n * await connectToBroker({\n *   driver: \"rabbitmq\",\n *   name: \"notifications\",\n *   isDefault: true,\n *   host: process.env.RABBITMQ_HOST,\n * });\n *\n * await connectToBroker({\n *   driver: \"rabbitmq\",\n *   name: \"analytics\",\n *   host: process.env.ANALYTICS_RABBITMQ_HOST,\n * });\n *\n * // Use default broker\n * herald().channel(\"notifications\").publish({ ... });\n *\n * // Use specific broker\n * herald(\"analytics\").channel(\"events\").publish({ ... });\n * ```\n */\nexport async function connectToBroker(options: ConnectionOptions): Promise<Broker> {\n  // Default values\n  const driverType = options.driver ?? \"rabbitmq\";\n  const brokerName = options.name ?? \"default\";\n  const isDefault = options.isDefault ?? true;\n\n  // Create driver based on type\n  let driver: BrokerDriverContract;\n\n  switch (driverType) {\n    case \"rabbitmq\": {\n      const rabbitOptions = options as RabbitMQConnectionOptions;\n      // Dynamic import to avoid requiring amqplib if not used\n      const { RabbitMQDriver } = await import(\"../drivers/rabbitmq/rabbitmq-driver\");\n      driver = new RabbitMQDriver(rabbitOptions);\n      break;\n    }\n\n    case \"kafka\": {\n      // const kafkaOptions = options as KafkaConnectionOptions;\n      // Dynamic import to avoid requiring kafkajs if not used\n      throw new Error(\n        \"Kafka driver is not yet implemented. Coming soon! For now, please use RabbitMQ.\",\n      );\n    }\n\n    default:\n      throw new Error(`Unknown driver: \"${driverType}\". Supported drivers: rabbitmq, kafka`);\n  }\n\n  // Create broker\n  const broker = brokerRegistry.register({\n    name: brokerName,\n    driver,\n    isDefault,\n  });\n\n  // Connect to the message broker\n  try {\n    await driver.connect();\n  } catch (error) {\n    throw new Error(\n      `Failed to connect to ${driverType}: ${error instanceof Error ? error.message : String(error)}`,\n    );\n  }\n\n  return broker;\n}\n\n/**\n * Get a broker by name or the default one.\n *\n * This is the main entry point for using brokers in your application.\n * Named after the package — `herald()` carries your messages!\n *\n * @param name - Optional broker name (uses default if not provided)\n * @returns Broker instance\n * @throws MissingBrokerError if broker not found\n *\n * @example\n * // Get default broker\n * const channel = herald().channel(\"user.created\");\n * await channel.publish({ userId: 1 });\n *\n * // Get specific broker\n * const analyticsChannel = herald(\"analytics\").channel(\"events\");\n * await analyticsChannel.publish({ event: \"page_view\" });\n *\n * // Subscribe to messages\n * herald()\n *   .channel<UserPayload>(\"user.created\")\n *   .subscribe(async (message, ctx) => {\n *     console.log(\"User created:\", message.payload);\n *     await ctx.ack();\n *   });\n * ```\n */\nexport function herald(name?: string): Broker {\n  return brokerRegistry.get(name);\n}\n\n/**\n * Get channel instance for the given name from default broker.\n *\n * Shorthand for `herald().channel(name, options)`.\n *\n * @param name - Channel name\n * @param options - Optional channel options\n * @returns Channel instance\n * @throws MissingBrokerError if broker not found\n *\n * @example\n * ```typescript\n * const channel = heraldChannel(\"user.created\");\n * await channel.publish({ userId: 1 });\n * ```\n */\nexport function heraldChannel<TPayload = unknown>(\n  name: string,\n  options?: ChannelOptions<TPayload>,\n): ChannelContract<TPayload> {\n  return herald().channel<TPayload>(name, options);\n}\n\n/**\n * Publish an EventMessage to the default broker.\n *\n * @param event - Event message to publish\n * @returns Promise that resolves when the event is published\n * @throws Error if the broker is not connected\n *\n * @example\n * ```typescript\n * await publishEvent(new UserUpdatedEvent({ id: 1, name: \"John Doe\" }));\n * ```\n */\nexport async function publishEvent<TPayload = Record<string, any>>(event: EventMessage<TPayload>) {\n  return herald().publish(event);\n}\n\n/**\n * Subscribe an EventConsumer class to the default broker.\n *\n * @param Consumer - Event consumer class\n * @returns Unsubscribe function\n * @throws MissingBrokerError if broker not found\n *\n * @example\n * ```typescript\n * await subscribeConsumer(UserUpdatedConsumer);\n * ```\n */\nexport async function subscribeConsumer<TPayload = Record<string, any>>(\n  Consumer: EventConsumerClass<TPayload>,\n) {\n  return herald().subscribe(Consumer);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,eAAsB,gBAAgB,SAA6C;CAEjF,MAAM,aAAa,QAAQ,UAAU;CACrC,MAAM,aAAa,QAAQ,QAAQ;CACnC,MAAM,YAAY,QAAQ,aAAa;CAGvC,IAAI;CAEJ,QAAQ,YAAR;EACE,KAAK,YAAY;GACf,MAAM,gBAAgB;GAEtB,MAAM,EAAE,mBAAmB,MAAM,OAAO;GACxC,SAAS,IAAI,eAAe,aAAa;GACzC;EACF;EAEA,KAAK,SAGH,MAAM,IAAI,MACR,iFACF;EAGF,SACE,MAAM,IAAI,MAAM,oBAAoB,WAAW,sCAAsC;CACzF;CAGA,MAAM,SAAS,eAAe,SAAS;EACrC,MAAM;EACN;EACA;CACF,CAAC;CAGD,IAAI;EACF,MAAM,OAAO,QAAQ;CACvB,SAAS,OAAO;EACd,MAAM,IAAI,MACR,wBAAwB,WAAW,IAAI,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GAC9F;CACF;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,OAAO,MAAuB;CAC5C,OAAO,eAAe,IAAI,IAAI;AAChC;;;;;;;;;;;;;;;;;AAkBA,SAAgB,cACd,MACA,SAC2B;CAC3B,OAAO,OAAO,CAAC,CAAC,QAAkB,MAAM,OAAO;AACjD;;;;;;;;;;;;;AAcA,eAAsB,aAA6C,OAA+B;CAChG,OAAO,OAAO,CAAC,CAAC,QAAQ,KAAK;AAC/B;;;;;;;;;;;;;AAcA,eAAsB,kBACpB,UACA;CACA,OAAO,OAAO,CAAC,CAAC,UAAU,QAAQ;AACpC"}
+{"version":3,"file":"connect-to-broker.mjs","names":[],"sources":["../../../../../../../../packages/herald/src/utils/connect-to-broker.ts"],"sourcesContent":["import { Broker, brokerRegistry } from \"../communicators\";\nimport type { BrokerDriverContract, ChannelContract } from \"../contracts\";\nimport { type EventConsumerClass, EventMessage } from \"../message-managers\";\nimport type { ChannelOptions, ConnectionOptions, RabbitMQConnectionOptions } from \"../types\";\n\n/**\n * Connect to a message broker and register it.\n *\n * This is a high-level utility function that simplifies connection setup\n * for most projects. It handles driver instantiation, connection,\n * broker creation, and automatic registration.\n *\n * **Supported Drivers:**\n * - `rabbitmq` (default) - RabbitMQ/AMQP driver\n * - `kafka` - Apache Kafka driver (coming soon)\n *\n * @param options - Connection configuration options\n * @returns A connected and registered Broker instance\n * @throws {Error} If connection fails or driver is not implemented\n *\n * @example\n * ```typescript\n * // RabbitMQ connection\n * const broker = await connectToBroker({\n *   driver: \"rabbitmq\",\n *   host: \"localhost\",\n *   port: 5672,\n *   username: \"guest\",\n *   password: \"guest\",\n * });\n *\n * // Use the broker\n * await broker.channel(\"user.created\").publish({ userId: 1 });\n * ```\n *\n * @example\n * ```typescript\n * // Multiple brokers\n * await connectToBroker({\n *   driver: \"rabbitmq\",\n *   name: \"notifications\",\n *   isDefault: true,\n *   host: process.env.RABBITMQ_HOST,\n * });\n *\n * await connectToBroker({\n *   driver: \"rabbitmq\",\n *   name: \"analytics\",\n *   host: process.env.ANALYTICS_RABBITMQ_HOST,\n * });\n *\n * // Use default broker\n * herald().channel(\"notifications\").publish({ ... });\n *\n * // Use specific broker\n * herald(\"analytics\").channel(\"events\").publish({ ... });\n * ```\n */\nexport async function connectToBroker(options: ConnectionOptions): Promise<Broker> {\n  // Default values\n  const driverType = options.driver ?? \"rabbitmq\";\n  const brokerName = options.name ?? \"default\";\n  const isDefault = options.isDefault ?? true;\n\n  // Create driver based on type\n  let driver: BrokerDriverContract;\n\n  switch (driverType) {\n    case \"rabbitmq\": {\n      const rabbitOptions = options as RabbitMQConnectionOptions;\n      // Dynamic import to avoid requiring amqplib if not used\n      const { RabbitMQDriver } = await import(\"../drivers/rabbitmq/rabbitmq-driver\");\n      driver = new RabbitMQDriver(rabbitOptions);\n      break;\n    }\n\n    case \"kafka\": {\n      // const kafkaOptions = options as KafkaConnectionOptions;\n      // Dynamic import to avoid requiring kafkajs if not used\n      throw new Error(\n        \"Kafka driver is not yet implemented. Coming soon! For now, please use RabbitMQ.\",\n      );\n    }\n\n    default:\n      throw new Error(`Unknown driver: \"${driverType}\". Supported drivers: rabbitmq, kafka`);\n  }\n\n  // Create broker\n  const broker = brokerRegistry.register({\n    name: brokerName,\n    driver,\n    isDefault,\n  });\n\n  // Connect to the message broker\n  try {\n    await driver.connect();\n  } catch (error) {\n    throw new Error(\n      `Failed to connect to ${driverType}: ${error instanceof Error ? error.message : String(error)}`,\n    );\n  }\n\n  return broker;\n}\n\n/**\n * Get a broker by name or the default one.\n *\n * This is the main entry point for using brokers in your application.\n * Named after the package — `herald()` carries your messages!\n *\n * @param name - Optional broker name (uses default if not provided)\n * @returns Broker instance\n * @throws MissingBrokerError if broker not found\n *\n * @example\n * // Get default broker\n * const channel = herald().channel(\"user.created\");\n * await channel.publish({ userId: 1 });\n *\n * // Get specific broker\n * const analyticsChannel = herald(\"analytics\").channel(\"events\");\n * await analyticsChannel.publish({ event: \"page_view\" });\n *\n * // Subscribe to messages\n * herald()\n *   .channel<UserPayload>(\"user.created\")\n *   .subscribe(async (message, ctx) => {\n *     console.log(\"User created:\", message.payload);\n *     await ctx.ack();\n *   });\n * ```\n */\nexport function herald(name?: string): Broker {\n  return brokerRegistry.get(name);\n}\n\n/**\n * Get channel instance for the given name from default broker.\n *\n * Shorthand for `herald().channel(name, options)`.\n *\n * @param name - Channel name\n * @param options - Optional channel options\n * @returns Channel instance\n * @throws MissingBrokerError if broker not found\n *\n * @example\n * ```typescript\n * const channel = heraldChannel(\"user.created\");\n * await channel.publish({ userId: 1 });\n * ```\n */\nexport function heraldChannel<TPayload = unknown>(\n  name: string,\n  options?: ChannelOptions<TPayload>,\n): ChannelContract<TPayload> {\n  return herald().channel<TPayload>(name, options);\n}\n\n/**\n * Publish an EventMessage to the default broker.\n *\n * @param event - Event message to publish\n * @returns Promise that resolves when the event is published\n * @throws Error if the broker is not connected\n *\n * @example\n * ```typescript\n * await publishEvent(new UserUpdatedEvent({ id: 1, name: \"John Doe\" }));\n * ```\n */\nexport async function publishEvent<TPayload = Record<string, any>>(event: EventMessage<TPayload>) {\n  return herald().publish(event);\n}\n\n/**\n * Subscribe an EventConsumer class to the default broker.\n *\n * @param Consumer - Event consumer class\n * @returns Unsubscribe function\n * @throws MissingBrokerError if broker not found\n *\n * @example\n * ```typescript\n * await subscribeConsumer(UserUpdatedConsumer);\n * ```\n */\nexport async function subscribeConsumer<TPayload = Record<string, any>>(\n  Consumer: EventConsumerClass<TPayload>,\n) {\n  return herald().subscribe(Consumer);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,eAAsB,gBAAgB,SAA6C;CAEjF,MAAM,aAAa,QAAQ,UAAU;CACrC,MAAM,aAAa,QAAQ,QAAQ;CACnC,MAAM,YAAY,QAAQ,aAAa;CAGvC,IAAI;CAEJ,QAAQ,YAAR;EACE,KAAK,YAAY;GACf,MAAM,gBAAgB;GAEtB,MAAM,EAAE,mBAAmB,MAAM,OAAO;GACxC,SAAS,IAAI,eAAe,aAAa;GACzC;EACF;EAEA,KAAK,SAGH,MAAM,IAAI,MACR,iFACF;EAGF,SACE,MAAM,IAAI,MAAM,oBAAoB,WAAW,sCAAsC;CACzF;CAGA,MAAM,SAAS,eAAe,SAAS;EACrC,MAAM;EACN;EACA;CACF,CAAC;CAGD,IAAI;EACF,MAAM,OAAO,QAAQ;CACvB,SAAS,OAAO;EACd,MAAM,IAAI,MACR,wBAAwB,WAAW,IAAI,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GAC9F;CACF;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,OAAO,MAAuB;CAC5C,OAAO,eAAe,IAAI,IAAI;AAChC;;;;;;;;;;;;;;;;;AAkBA,SAAgB,cACd,MACA,SAC2B;CAC3B,OAAO,OAAO,CAAC,CAAC,QAAkB,MAAM,OAAO;AACjD;;;;;;;;;;;;;AAcA,eAAsB,aAA6C,OAA+B;CAChG,OAAO,OAAO,CAAC,CAAC,QAAQ,KAAK;AAC/B;;;;;;;;;;;;;AAcA,eAAsB,kBACpB,UACA;CACA,OAAO,OAAO,CAAC,CAAC,UAAU,QAAQ;AACpC"}

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,12 +8,13 @@
     "@mongez/copper": "^2.1.3",
     "@mongez/events": "^2.2.8",
     "@mongez/reinforcements": "^4.0.2",
-    "@warlock.js/logger": "5.29.0",
-    "@warlock.js/seal": "5.29.0"
+    "@warlock.js/logger": "5.31.0",
+    "@warlock.js/seal": "5.31.0"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/warlockjs/herald"
+    "url": "git+https://github.com/warlockjs/framework.git",
+    "directory": "packages/herald"
   },
   "peerDependencies": {
     "amqplib": "^0.10.0"
@@ -36,7 +37,7 @@
   ],
   "author": "hassanzohdy",
   "license": "MIT",
-  "version": "5.29.0",
+  "version": "5.31.0",
   "main": "./cjs/index.cjs",
   "module": "./esm/index.mjs",
   "types": "./esm/index.d.mts",

package/skills/consume-message/SKILL.md

@@ -17,9 +17,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
     }
   });
 ```
@@ -30,7 +30,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
 
@@ -44,23 +44,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: {
@@ -101,10 +101,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`
@@ -115,7 +117,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";
 
@@ -167,7 +169,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);
   },
@@ -183,11 +185,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()`.
@@ -198,10 +200,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.

package/skills/herald-basics/SKILL.md

@@ -73,20 +73,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