@warlock.js/notifications 4.15.0 → 5.0.0

package/esm/herald/src/drivers/rabbitmq/rabbitmq-driver.mjs

@@ -0,0 +1,303 @@
+import { __toESM } from "../../../../_virtual/_rolldown/runtime.mjs";
+import { prepareConsumerSubscription } from "../../message-managers/prepare-consumer-subscription.mjs";
+import { RabbitMQChannel } from "./rabbitmq-channel.mjs";
+import { EventEmitter } from "node:events";
+
+//#region ../herald/src/drivers/rabbitmq/rabbitmq-driver.ts
+/**
+* The single amqplib load, shared by every caller.
+*
+* Memoized as a promise rather than as a resolved value so the loader stays
+* idempotent: without it, two callers arriving before the first `import()`
+* settles would each start their own load and the last writer would win, so a
+* caller could end up observing a module instance it never awaited.
+*
+* Resolves to `undefined` when amqplib is not installed.
+*/
+let amqplibModulePromise;
+/**
+* Installation instructions for amqplib
+*/
+const AMQPLIB_INSTALL_INSTRUCTIONS = `
+RabbitMQ driver requires the amqplib package.
+Install it with:
+
+  npx warlock add herald --driver=rabbitmq
+
+Or manually:
+
+  npm install amqplib
+  pnpm add amqplib
+  yarn add amqplib
+`.trim();
+/**
+* Strip `user:password@` credentials from any `amqp(s)://` URL embedded in a
+* string. The connection URL carries plaintext broker credentials, and
+* amqplib/Node's URL parser commonly echoes the offending URL verbatim in a
+* malformed-URL error (e.g. an unencoded `@`/`:` in the password) — applied
+* to every error `connect()` surfaces so a credential never reaches whatever
+* the host app does with a thrown connection error (console.error,
+* structured logging, an error tracker).
+*/
+function redactAmqpCredentials(message) {
+	return message.replace(/(amqps?:\/\/)[^/@\s]+@/gi, "$1****:****@");
+}
+/**
+* Load amqplib, reusing the single shared load for every caller.
+*
+* @returns The amqplib module, or `undefined` when it is not installed.
+*/
+function loadAmqplibModule() {
+	if (!amqplibModulePromise) amqplibModulePromise = import("../../../../node_modules/amqplib/channel_api.mjs").then((m) => /* @__PURE__ */ __toESM(m.default, 1)).catch(() => void 0);
+	return amqplibModulePromise;
+}
+/**
+* RabbitMQ Driver
+*
+* Implementation of BrokerDriverContract for RabbitMQ/AMQP.
+*
+* **Important:** This driver requires the `amqplib` package to be installed.
+* Install it with: `npx warlock add herald --driver=rabbitmq` or `npm install amqplib`
+*
+* @example
+* ```typescript
+* const driver = new RabbitMQDriver({
+*   driver: "rabbitmq",
+*   host: "localhost",
+*   port: 5672,
+*   username: "guest",
+*   password: "guest",
+* });
+*
+* await driver.connect();
+* const channel = driver.channel("user.created");
+* ```
+*/
+var RabbitMQDriver = class {
+	name = "rabbitmq";
+	consumers = [];
+	options;
+	events = new EventEmitter();
+	channels = /* @__PURE__ */ new Map();
+	connection = null;
+	amqpChannel = null;
+	_isConnected = false;
+	/**
+	* Create a new RabbitMQ driver
+	*
+	* @param options - RabbitMQ connection options
+	*/
+	constructor(options) {
+		this.options = options;
+	}
+	/**
+	* Whether connected to RabbitMQ
+	*/
+	get isConnected() {
+		return this._isConnected;
+	}
+	/**
+	* Subscribe the given consumer class to the driver
+	*
+	* @param consumer - Consumer class to subscribe
+	*
+	* @example
+	* ```typescript
+	* driver.subscribe(UserUpdatedConsumer);
+	* ```
+	*/
+	subscribe(Consumer) {
+		if (this.isConnected) this.channel(Consumer.eventName).subscribe(prepareConsumerSubscription(Consumer, (error, eventName) => {
+			this.events.emit("error", error, eventName);
+		}), { consumerId: Consumer.consumerId });
+		else this.consumers.push(Consumer);
+		return () => {
+			this.unsubscribe(Consumer);
+		};
+	}
+	/**
+	* Unsubscribe the given consumer
+	*/
+	unsubscribe(Consumer) {
+		if (this.isConnected) this.channel(Consumer.eventName).unsubscribeById(Consumer.consumerId);
+		const index = this.consumers.indexOf(Consumer);
+		if (index > -1) this.consumers.splice(index, 1);
+	}
+	/**
+	* Publish the given event message.
+	* Auto-creates the channel if it hasn't been accessed before.
+	*/
+	publish(event) {
+		this.channel(event.eventName).publish(event.serialize());
+	}
+	/**
+	* Connect to RabbitMQ
+	*/
+	async connect() {
+		const amqplib = await loadAmqplibModule();
+		if (!amqplib) throw new Error(`amqplib is not installed.\n\n${AMQPLIB_INSTALL_INSTRUCTIONS}`);
+		try {
+			const url = this.buildConnectionUrl();
+			const connectOptions = {
+				heartbeat: this.options.heartbeat ?? 60,
+				timeout: this.options.connectionTimeout,
+				...this.options.clientOptions
+			};
+			this.connection = await amqplib.connect(url, connectOptions);
+			this.amqpChannel = await this.connection.createChannel();
+			if (this.options.prefetch) await this.amqpChannel.prefetch(this.options.prefetch);
+			this._isConnected = true;
+			this.events.emit("connected");
+			for (const consumer of this.consumers) this.subscribe(consumer);
+			this.consumers.length = 0;
+			this.connection.on("close", () => {
+				this._isConnected = false;
+				this.events.emit("disconnected");
+				if (this.options.reconnect !== false) this.handleReconnect();
+			});
+			this.connection.on("error", (error) => {
+				this.events.emit("error", error);
+			});
+		} catch (error) {
+			this._isConnected = false;
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(`Failed to connect to RabbitMQ: ${redactAmqpCredentials(message)}`);
+		}
+	}
+	/**
+	* Build connection URL from options
+	*/
+	buildConnectionUrl() {
+		if (this.options.uri) return this.options.uri;
+		const protocol = "amqp";
+		const host = this.options.host ?? "localhost";
+		const port = this.options.port ?? 5672;
+		const vhost = this.options.vhost ?? "/";
+		return `${protocol}://${encodeURIComponent(this.options.username ?? "guest")}:${encodeURIComponent(this.options.password ?? "guest")}@${host}:${port}/${encodeURIComponent(vhost)}`;
+	}
+	/**
+	* Handle reconnection
+	*/
+	async handleReconnect() {
+		const delay = this.options.reconnectDelay ?? 5e3;
+		let attempt = 0;
+		const tryReconnect = async () => {
+			attempt++;
+			this.events.emit("reconnecting", attempt);
+			try {
+				await this.connect();
+			} catch {
+				setTimeout(tryReconnect, delay);
+			}
+		};
+		setTimeout(tryReconnect, delay);
+	}
+	/**
+	* Disconnect from RabbitMQ
+	*/
+	async disconnect() {
+		if (this.amqpChannel) {
+			try {
+				await this.amqpChannel.close();
+			} catch {}
+			this.amqpChannel = null;
+		}
+		if (this.connection) {
+			try {
+				await this.connection.close();
+			} catch {}
+			this.connection = null;
+		}
+		this._isConnected = false;
+		this.events.emit("disconnected");
+	}
+	/**
+	* Register event listener
+	*/
+	on(event, listener) {
+		this.events.on(event, listener);
+	}
+	/**
+	* Remove event listener
+	*/
+	off(event, listener) {
+		this.events.off(event, listener);
+	}
+	/**
+	* Get or create a channel
+	*/
+	channel(name, options) {
+		const existing = this.channels.get(name);
+		if (existing) return existing;
+		const channel = new RabbitMQChannel(name, this.amqpChannel, options);
+		this.channels.set(name, channel);
+		return channel;
+	}
+	/**
+	* Start consuming messages
+	*/
+	async startConsuming() {}
+	/**
+	* Stop consuming messages from all subscribed channels.
+	* Gracefully cancels all active consumers.
+	*/
+	async stopConsuming() {
+		const stops = Array.from(this.channels.values()).map((channel) => channel.stopConsuming());
+		await Promise.all(stops);
+	}
+	/**
+	* Health check
+	*/
+	async healthCheck() {
+		if (!this._isConnected || !this.connection) return {
+			healthy: false,
+			error: "Not connected to RabbitMQ"
+		};
+		const start = Date.now();
+		try {
+			await this.amqpChannel.checkQueue("amq.rabbitmq.reply-to").catch(() => {});
+			return {
+				healthy: true,
+				latency: Date.now() - start
+			};
+		} catch (error) {
+			return {
+				healthy: false,
+				error: error instanceof Error ? error.message : String(error),
+				latency: Date.now() - start
+			};
+		}
+	}
+	/**
+	* Get all channel names
+	*/
+	getChannelNames() {
+		return Array.from(this.channels.keys());
+	}
+	/**
+	* Close a specific channel
+	*/
+	async closeChannel(name) {
+		const channel = this.channels.get(name);
+		if (channel) {
+			await channel.delete();
+			this.channels.delete(name);
+		}
+	}
+	/**
+	* Get the raw AMQP channel (for advanced use)
+	*/
+	getRawChannel() {
+		return this.amqpChannel;
+	}
+	/**
+	* Get the raw connection (for advanced use)
+	*/
+	getRawConnection() {
+		return this.connection;
+	}
+};
+
+//#endregion
+export { RabbitMQDriver };
+//# sourceMappingURL=rabbitmq-driver.mjs.map

package/esm/herald/src/drivers/rabbitmq/rabbitmq-driver.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rabbitmq-driver.mjs","names":[],"sources":["../../../../../../../../../../herald/src/drivers/rabbitmq/rabbitmq-driver.ts"],"sourcesContent":["import { EventEmitter } from \"node:events\";\r\nimport type { BrokerDriverContract, ChannelContract } from \"../../contracts\";\r\nimport { EventMessage } from \"../../message-managers/event-message\";\r\nimport { EventConsumerClass } from \"../../message-managers/types\";\r\nimport type {\r\n  BrokerDriverType,\r\n  BrokerEvent,\r\n  BrokerEventListener,\r\n  ChannelOptions,\r\n  HealthCheckResult,\r\n  RabbitMQConnectionOptions,\r\n} from \"../../types\";\r\nimport { prepareConsumerSubscription } from \"./../../message-managers/prepare-consumer-subscription\";\r\nimport { RabbitMQChannel } from \"./rabbitmq-channel\";\r\n\r\n// ============================================================\r\n// Lazy-loaded amqplib Module\r\n// ============================================================\r\n\r\n/**\r\n * Shape of the lazily-imported amqplib module\r\n */\r\ntype AmqplibModule = typeof import(\"amqplib\");\r\n\r\n/**\r\n * The single amqplib load, shared by every caller.\r\n *\r\n * Memoized as a promise rather than as a resolved value so the loader stays\r\n * idempotent: without it, two callers arriving before the first `import()`\r\n * settles would each start their own load and the last writer would win, so a\r\n * caller could end up observing a module instance it never awaited.\r\n *\r\n * Resolves to `undefined` when amqplib is not installed.\r\n */\r\nlet amqplibModulePromise: Promise<AmqplibModule | undefined> | undefined;\r\n\r\n/**\r\n * Installation instructions for amqplib\r\n */\r\nconst AMQPLIB_INSTALL_INSTRUCTIONS = `\r\nRabbitMQ driver requires the amqplib package.\r\nInstall it with:\r\n\r\n  npx warlock add herald --driver=rabbitmq\r\n\r\nOr manually:\r\n\r\n  npm install amqplib\r\n  pnpm add amqplib\r\n  yarn add amqplib\r\n`.trim();\r\n\r\n/**\r\n * Strip `user:password@` credentials from any `amqp(s)://` URL embedded in a\r\n * string. The connection URL carries plaintext broker credentials, and\r\n * amqplib/Node's URL parser commonly echoes the offending URL verbatim in a\r\n * malformed-URL error (e.g. an unencoded `@`/`:` in the password) — applied\r\n * to every error `connect()` surfaces so a credential never reaches whatever\r\n * the host app does with a thrown connection error (console.error,\r\n * structured logging, an error tracker).\r\n */\r\nfunction redactAmqpCredentials(message: string): string {\r\n  return message.replace(/(amqps?:\\/\\/)[^/@\\s]+@/gi, \"$1****:****@\");\r\n}\r\n\r\n/**\r\n * Load amqplib, reusing the single shared load for every caller.\r\n *\r\n * @returns The amqplib module, or `undefined` when it is not installed.\r\n */\r\nfunction loadAmqplibModule(): Promise<AmqplibModule | undefined> {\r\n  if (!amqplibModulePromise) {\r\n    amqplibModulePromise = import(\"amqplib\").catch(() => undefined);\r\n  }\r\n\r\n  return amqplibModulePromise;\r\n}\r\n\r\n// ============================================================\r\n// RabbitMQ Driver\r\n// ============================================================\r\n\r\n/**\r\n * RabbitMQ Driver\r\n *\r\n * Implementation of BrokerDriverContract for RabbitMQ/AMQP.\r\n *\r\n * **Important:** This driver requires the `amqplib` package to be installed.\r\n * Install it with: `npx warlock add herald --driver=rabbitmq` or `npm install amqplib`\r\n *\r\n * @example\r\n * ```typescript\r\n * const driver = new RabbitMQDriver({\r\n *   driver: \"rabbitmq\",\r\n *   host: \"localhost\",\r\n *   port: 5672,\r\n *   username: \"guest\",\r\n *   password: \"guest\",\r\n * });\r\n *\r\n * await driver.connect();\r\n * const channel = driver.channel(\"user.created\");\r\n * ```\r\n */\r\nexport class RabbitMQDriver implements BrokerDriverContract {\r\n  public readonly name = \"rabbitmq\" as const;\r\n\r\n  public readonly consumers: EventConsumerClass[] = [];\r\n\r\n  private readonly options: RabbitMQConnectionOptions;\r\n  private readonly events = new EventEmitter();\r\n  private readonly channels = new Map<string, ChannelContract<any>>();\r\n\r\n  private connection: any = null;\r\n  private amqpChannel: any = null;\r\n  private _isConnected = false;\r\n\r\n  /**\r\n   * Create a new RabbitMQ driver\r\n   *\r\n   * @param options - RabbitMQ connection options\r\n   */\r\n  public constructor(options: RabbitMQConnectionOptions) {\r\n    this.options = options;\r\n  }\r\n\r\n  /**\r\n   * Whether connected to RabbitMQ\r\n   */\r\n  public get isConnected(): boolean {\r\n    return this._isConnected;\r\n  }\r\n\r\n  /**\r\n   * Subscribe the given consumer class to the driver\r\n   *\r\n   * @param consumer - Consumer class to subscribe\r\n   *\r\n   * @example\r\n   * ```typescript\r\n   * driver.subscribe(UserUpdatedConsumer);\r\n   * ```\r\n   */\r\n  public subscribe(Consumer: EventConsumerClass) {\r\n    if (this.isConnected) {\r\n      this.channel(Consumer.eventName).subscribe(\r\n        prepareConsumerSubscription(Consumer, (error, eventName) => {\r\n          this.events.emit(\"error\", error, eventName);\r\n        }),\r\n        {\r\n          consumerId: Consumer.consumerId,\r\n        },\r\n      );\r\n    } else {\r\n      this.consumers.push(Consumer);\r\n    }\r\n\r\n    return () => {\r\n      this.unsubscribe(Consumer);\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Unsubscribe the given consumer\r\n   */\r\n  public unsubscribe(Consumer: EventConsumerClass): void {\r\n    if (this.isConnected) {\r\n      this.channel(Consumer.eventName).unsubscribeById(Consumer.consumerId);\r\n    }\r\n    const index = this.consumers.indexOf(Consumer);\r\n    if (index > -1) {\r\n      this.consumers.splice(index, 1);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Publish the given event message.\r\n   * Auto-creates the channel if it hasn't been accessed before.\r\n   */\r\n  public publish<TPayload = Record<string, any>>(event: EventMessage<TPayload>): void {\r\n    this.channel(event.eventName).publish(event.serialize());\r\n  }\r\n\r\n  /**\r\n   * Connect to RabbitMQ\r\n   */\r\n  public async connect(): Promise<void> {\r\n    const amqplib = await loadAmqplibModule();\r\n\r\n    if (!amqplib) {\r\n      throw new Error(`amqplib is not installed.\\n\\n${AMQPLIB_INSTALL_INSTRUCTIONS}`);\r\n    }\r\n\r\n    try {\r\n      // Build connection URL\r\n      const url = this.buildConnectionUrl();\r\n\r\n      // Build connection options merging our options with native client options\r\n      const connectOptions = {\r\n        heartbeat: this.options.heartbeat ?? 60,\r\n        timeout: this.options.connectionTimeout,\r\n        // Merge native amqplib client options\r\n        ...this.options.clientOptions,\r\n      };\r\n\r\n      // Connect using cached module\r\n      this.connection = await amqplib.connect(url, connectOptions);\r\n\r\n      // Create channel\r\n      this.amqpChannel = await this.connection.createChannel();\r\n\r\n      // Set prefetch if specified\r\n      if (this.options.prefetch) {\r\n        await this.amqpChannel.prefetch(this.options.prefetch);\r\n      }\r\n\r\n      this._isConnected = true;\r\n      this.events.emit(\"connected\");\r\n\r\n      for (const consumer of this.consumers) {\r\n        this.subscribe(consumer);\r\n      }\r\n\r\n      this.consumers.length = 0;\r\n\r\n      // Handle connection close\r\n      this.connection.on(\"close\", () => {\r\n        this._isConnected = false;\r\n        this.events.emit(\"disconnected\");\r\n\r\n        if (this.options.reconnect !== false) {\r\n          this.handleReconnect();\r\n        }\r\n      });\r\n\r\n      // Handle errors\r\n      this.connection.on(\"error\", (error: Error) => {\r\n        this.events.emit(\"error\", error);\r\n      });\r\n    } catch (error) {\r\n      this._isConnected = false;\r\n      const message = error instanceof Error ? error.message : String(error);\r\n      throw new Error(`Failed to connect to RabbitMQ: ${redactAmqpCredentials(message)}`);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Build connection URL from options\r\n   */\r\n  private buildConnectionUrl(): string {\r\n    if (this.options.uri) {\r\n      return this.options.uri;\r\n    }\r\n\r\n    const protocol = \"amqp\";\r\n    const host = this.options.host ?? \"localhost\";\r\n    const port = this.options.port ?? 5672;\r\n    const vhost = this.options.vhost ?? \"/\";\r\n    // URI-encoded so a credential containing a reserved URL character\r\n    // (`@`, `:`, `/`, whitespace — common in generated secrets) can't produce\r\n    // a malformed URL whose parser error echoes the raw credential back.\r\n    const username = encodeURIComponent(this.options.username ?? \"guest\");\r\n    const password = encodeURIComponent(this.options.password ?? \"guest\");\r\n\r\n    const encodedVhost = encodeURIComponent(vhost);\r\n\r\n    return `${protocol}://${username}:${password}@${host}:${port}/${encodedVhost}`;\r\n  }\r\n\r\n  /**\r\n   * Handle reconnection\r\n   */\r\n  private async handleReconnect(): Promise<void> {\r\n    const delay = this.options.reconnectDelay ?? 5000;\r\n    let attempt = 0;\r\n\r\n    const tryReconnect = async () => {\r\n      attempt++;\r\n      this.events.emit(\"reconnecting\", attempt);\r\n\r\n      try {\r\n        await this.connect();\r\n      } catch {\r\n        setTimeout(tryReconnect, delay);\r\n      }\r\n    };\r\n\r\n    setTimeout(tryReconnect, delay);\r\n  }\r\n\r\n  /**\r\n   * Disconnect from RabbitMQ\r\n   */\r\n  public async disconnect(): Promise<void> {\r\n    if (this.amqpChannel) {\r\n      try {\r\n        await this.amqpChannel.close();\r\n      } catch {\r\n        // Ignore close errors\r\n      }\r\n      this.amqpChannel = null;\r\n    }\r\n\r\n    if (this.connection) {\r\n      try {\r\n        await this.connection.close();\r\n      } catch {\r\n        // Ignore close errors\r\n      }\r\n      this.connection = null;\r\n    }\r\n\r\n    this._isConnected = false;\r\n    this.events.emit(\"disconnected\");\r\n  }\r\n\r\n  /**\r\n   * Register event listener\r\n   */\r\n  public on(event: BrokerEvent, listener: BrokerEventListener): void {\r\n    this.events.on(event, listener as any);\r\n  }\r\n\r\n  /**\r\n   * Remove event listener\r\n   */\r\n  public off(event: BrokerEvent, listener: BrokerEventListener): void {\r\n    this.events.off(event, listener as any);\r\n  }\r\n\r\n  /**\r\n   * Get or create a channel\r\n   */\r\n  public channel<TPayload = unknown>(\r\n    name: string,\r\n    options?: ChannelOptions<TPayload>,\r\n  ): ChannelContract<TPayload> {\r\n    // Check cache\r\n    const existing = this.channels.get(name);\r\n    if (existing) {\r\n      return existing as ChannelContract<TPayload>;\r\n    }\r\n\r\n    // Create new channel\r\n    const channel = new RabbitMQChannel<TPayload>(name, this.amqpChannel, options);\r\n\r\n    this.channels.set(name, channel);\r\n    return channel;\r\n  }\r\n\r\n  /**\r\n   * Start consuming messages\r\n   */\r\n  public async startConsuming(): Promise<void> {\r\n    // Channels start consuming when subscribe() is called\r\n    // This method is for batch start if needed\r\n  }\r\n\r\n  /**\r\n   * Stop consuming messages from all subscribed channels.\r\n   * Gracefully cancels all active consumers.\r\n   */\r\n  public async stopConsuming(): Promise<void> {\r\n    const stops = Array.from(this.channels.values()).map(channel =>\r\n      (channel as RabbitMQChannel<any>).stopConsuming(),\r\n    );\r\n    await Promise.all(stops);\r\n  }\r\n\r\n  /**\r\n   * Health check\r\n   */\r\n  public async healthCheck(): Promise<HealthCheckResult> {\r\n    if (!this._isConnected || !this.connection) {\r\n      return {\r\n        healthy: false,\r\n        error: \"Not connected to RabbitMQ\",\r\n      };\r\n    }\r\n\r\n    const start = Date.now();\r\n\r\n    try {\r\n      // Simple check - verify channel is open\r\n      await this.amqpChannel.checkQueue(\"amq.rabbitmq.reply-to\").catch(() => {\r\n        // Queue might not exist, but if we get here, connection is alive\r\n      });\r\n\r\n      return {\r\n        healthy: true,\r\n        latency: Date.now() - start,\r\n      };\r\n    } catch (error) {\r\n      return {\r\n        healthy: false,\r\n        error: error instanceof Error ? error.message : String(error),\r\n        latency: Date.now() - start,\r\n      };\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get all channel names\r\n   */\r\n  public getChannelNames(): string[] {\r\n    return Array.from(this.channels.keys());\r\n  }\r\n\r\n  /**\r\n   * Close a specific channel\r\n   */\r\n  public async closeChannel(name: string): Promise<void> {\r\n    const channel = this.channels.get(name);\r\n    if (channel) {\r\n      await channel.delete();\r\n      this.channels.delete(name);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get the raw AMQP channel (for advanced use)\r\n   */\r\n  public getRawChannel(): any {\r\n    return this.amqpChannel;\r\n  }\r\n\r\n  /**\r\n   * Get the raw connection (for advanced use)\r\n   */\r\n  public getRawConnection(): any {\r\n    return this.connection;\r\n  }\r\n}\r\n"],"mappings":"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"}

package/esm/herald/src/index.mjs

@@ -0,0 +1,16 @@
+import { RabbitMQChannel } from "./drivers/rabbitmq/rabbitmq-channel.mjs";
+import { RabbitMQDriver } from "./drivers/rabbitmq/rabbitmq-driver.mjs";
+import { Broker } from "./communicators/broker.mjs";
+import { MissingBrokerError, brokerRegistry } from "./communicators/broker-registry.mjs";
+import "./communicators/index.mjs";
+import "./drivers/index.mjs";
+import { connectToBroker, herald, heraldChannel, publishEvent, subscribeConsumer } from "./utils/connect-to-broker.mjs";
+import "./utils/index.mjs";
+import { Consumable, pendingSubscribers } from "./decorators/consumable.mjs";
+import "./decorators/index.mjs";
+import { EventConsumer, defineConsumer } from "./message-managers/event-consumer.mjs";
+import { EventMessage, defineEvent } from "./message-managers/event-message.mjs";
+import "./message-managers/index.mjs";
+import { heraldBroadcast } from "./use-case-broadcast.mjs";
+
+export { Broker, Consumable, EventConsumer, EventMessage, MissingBrokerError, RabbitMQChannel, RabbitMQDriver, brokerRegistry, connectToBroker, defineConsumer, defineEvent, herald, heraldBroadcast, heraldChannel, pendingSubscribers, publishEvent, subscribeConsumer };

package/esm/herald/src/message-managers/event-consumer.mjs

@@ -0,0 +1,76 @@
+import { v } from "../../../seal/src/factory/validators.mjs";
+import "../../../seal/src/index.mjs";
+import { Consumable } from "../decorators/consumable.mjs";
+import "../decorators/index.mjs";
+import { randomUUID } from "crypto";
+
+//#region ../herald/src/message-managers/event-consumer.ts
+/**
+* This class is used to be part of the Herald Event Consumer Manager.
+* It should be used to consume events from Either RabbitMQ or Kafka through Herald
+*
+* It's highly recommended using it instead of declaring manual channel namd and subscribing to event
+*/
+var EventConsumer = class {
+	/**
+	* Event name
+	*/
+	static eventName;
+	static _consumerId;
+	static get consumerId() {
+		if (!this._consumerId) this._consumerId = randomUUID();
+		return this._consumerId;
+	}
+	get eventName() {
+		return this.constructor.eventName;
+	}
+	/**
+	* Min version accepted to be consumed by this class
+	*/
+	static minVersion;
+	/**
+	* Max version accepted to be consumed by this class
+	*/
+	static maxVersion;
+	/**
+	* Payload validation to auto reject the received event before accessing it in the handle method
+	*/
+	schema;
+	/**
+	* Determine whether this is accepted version to be used by this consumer
+	*/
+	static isAcceptedVersion(version) {
+		if (this.minVersion && version < this.minVersion) return false;
+		if (this.maxVersion && version > this.maxVersion) return false;
+		return true;
+	}
+	/**
+	* Validate the given data
+	*/
+	async validate(data) {
+		if (!this.schema) return;
+		return await v.validate(this.schema, data);
+	}
+};
+/**
+* A shorthand to define an event consumer without declaring an entire class
+*/
+function defineConsumer(eventName, options) {
+	const Class = class AnnouncedConsumer extends EventConsumer {
+		static eventName = eventName;
+		schema = options.schema;
+		async handle(payload, event) {
+			if (options.validate) {
+				const result = await options.validate(payload);
+				if (!result || !result.isValid) return;
+			}
+			return options.handle(payload, event);
+		}
+	};
+	Consumable()(Class);
+	return Class;
+}
+
+//#endregion
+export { EventConsumer, defineConsumer };
+//# sourceMappingURL=event-consumer.mjs.map

package/esm/herald/src/message-managers/event-consumer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-consumer.mjs","names":[],"sources":["../../../../../../../../../herald/src/message-managers/event-consumer.ts"],"sourcesContent":["/**\n * This class is used to be part of the Herald Event Consumer Manager.\n * It should be used to consume events from Either RabbitMQ or Kafka through Herald\n *\n * It's highly recommended using it instead of declaring manual channel namd and subscribing to event\n */\nimport { v, ValidationResult, type ObjectValidator } from \"@warlock.js/seal\";\nimport { randomUUID } from \"crypto\";\nimport { Consumable } from \"../decorators\";\nimport { ConsumedEventMessage, EventConsumerClass } from \"./types\";\n\nexport abstract class EventConsumer<Payload = Record<string, any>> {\n  /**\n   * Event name\n   */\n  public static eventName: string;\n\n  private static _consumerId?: string;\n\n  public static get consumerId(): string {\n    if (!this._consumerId) {\n      this._consumerId = randomUUID();\n    }\n    return this._consumerId;\n  }\n\n  public get eventName() {\n    return (this.constructor as typeof EventConsumer).eventName;\n  }\n\n  /**\n   * Min version accepted to be consumed by this class\n   */\n  public static minVersion?: number;\n\n  /**\n   * Max version accepted to be consumed by this class\n   */\n  public static maxVersion?: number;\n\n  /**\n   * Payload validation to auto reject the received event before accessing it in the handle method\n   */\n  public schema?: ObjectValidator;\n\n  /**\n   * The method that will be called when the event is received\n   */\n  public abstract handle(payload: Payload, event: ConsumedEventMessage): Promise<void>;\n\n  /**\n   * Determine whether this is accepted version to be used by this consumer\n   */\n  public static isAcceptedVersion(version: number): boolean {\n    if (this.minVersion && version < this.minVersion) return false;\n    if (this.maxVersion && version > this.maxVersion) return false;\n\n    return true;\n  }\n\n  /**\n   * Validate the given data\n   */\n  public async validate(data: Payload): Promise<ValidationResult | void> {\n    if (!this.schema) return;\n\n    return await v.validate(this.schema, data);\n  }\n}\n\n/**\n * Define Consumer options\n */\ntype ConsumerOptions<Payload> = {\n  /**\n   * Payload validation to auto reject the received event before accessing it in the handle method\n   */\n  schema?: ObjectValidator;\n  /**\n   * Handle data\n   */\n  handle: (payload: Payload, event: ConsumedEventMessage) => Promise<void>;\n  /**\n   * Validate the payload before executing `handle`\n   */\n  validate?: (payload: Payload) => Promise<ValidationResult | boolean>;\n};\n\n/**\n * A shorthand to define an event consumer without declaring an entire class\n */\nexport function defineConsumer<Payload = Record<string, any>>(\n  eventName: string,\n  options: ConsumerOptions<Payload>,\n): EventConsumerClass {\n  const Class = class AnnouncedConsumer extends EventConsumer<Payload> {\n    public static eventName = eventName;\n    public schema = options.schema;\n\n    public async handle(payload: Payload, event: ConsumedEventMessage) {\n      if (options.validate) {\n        const result = await options.validate(payload);\n        if (!result || !(result as ValidationResult).isValid) return;\n      }\n\n      return options.handle(payload, event);\n    }\n  };\n\n  Consumable()(Class as EventConsumerClass);\n\n  return Class as EventConsumerClass;\n}\n"],"mappings":";;;;;;;;;;;;;AAWA,IAAsB,gBAAtB,MAAmE;;;;CAIjE,OAAc;CAEd,OAAe;CAEf,WAAkB,aAAqB;EACrC,IAAI,CAAC,KAAK,aACR,KAAK,cAAc,WAAW;EAEhC,OAAO,KAAK;CACd;CAEA,IAAW,YAAY;EACrB,OAAQ,KAAK,YAAqC;CACpD;;;;CAKA,OAAc;;;;CAKd,OAAc;;;;CAKd,AAAO;;;;CAUP,OAAc,kBAAkB,SAA0B;EACxD,IAAI,KAAK,cAAc,UAAU,KAAK,YAAY,OAAO;EACzD,IAAI,KAAK,cAAc,UAAU,KAAK,YAAY,OAAO;EAEzD,OAAO;CACT;;;;CAKA,MAAa,SAAS,MAAiD;EACrE,IAAI,CAAC,KAAK,QAAQ;EAElB,OAAO,MAAM,EAAE,SAAS,KAAK,QAAQ,IAAI;CAC3C;AACF;;;;AAuBA,SAAgB,eACd,WACA,SACoB;CACpB,MAAM,QAAQ,MAAM,0BAA0B,cAAuB;EACnE,OAAc,YAAY;EAC1B,AAAO,SAAS,QAAQ;EAExB,MAAa,OAAO,SAAkB,OAA6B;GACjE,IAAI,QAAQ,UAAU;IACpB,MAAM,SAAS,MAAM,QAAQ,SAAS,OAAO;IAC7C,IAAI,CAAC,UAAU,CAAE,OAA4B,SAAS;GACxD;GAEA,OAAO,QAAQ,OAAO,SAAS,KAAK;EACtC;CACF;CAEA,WAAW,CAAC,CAAC,KAA2B;CAExC,OAAO;AACT"}

package/esm/herald/src/message-managers/event-message.mjs

@@ -0,0 +1,85 @@
+import { randomUUID } from "crypto";
+
+//#region ../herald/src/message-managers/event-message.ts
+var EventMessage = class {
+	data;
+	/**
+	* Event version
+	*/
+	version;
+	/**
+	* Additional metadata (if any)
+	*/
+	metadata;
+	/**
+	* Event Message id
+	*/
+	messageId;
+	/**
+	* Schema of payload that will be used to determine whether this event should be published
+	*/
+	schema;
+	/**
+	* Data that will be sent with the event (Payload)
+	*/
+	toJSON() {
+		if (!this.data) throw new Error(`no Data is defined for Event: ${this.eventName}`);
+		return this.data;
+	}
+	constructor(data) {
+		this.data = data;
+	}
+	/**
+	* Serialize the event to be ready for publishing.
+	* Delegates payload resolution to toJSON() — override toJSON() to customize.
+	*
+	* @throws Error if toJSON() throws (e.g. no data provided)
+	*/
+	serialize() {
+		return {
+			payload: this.toJSON(),
+			metadata: this.metadata,
+			messageId: this.messageId ?? randomUUID(),
+			eventName: this.eventName,
+			version: this.version,
+			occurredAt: /* @__PURE__ */ new Date(),
+			__through: "EventMessage"
+		};
+	}
+};
+/**
+* A shorthand to define an event without declaring an entire class.
+*
+* This factory function creates an EventMessage subclass that transforms
+* input data (IncomingData) into a different output format (OutgoingData).
+*
+* @template IncomingData - The type of data passed to the constructor
+* @template OutgoingData - The type of data returned by toJSON()
+*
+* @example
+* ```typescript
+* const UserCreatedEvent = defineEvent<User, { id: number; name: string }>(
+*   "user.created",
+*   { toJSON: (user) => user.only(["id", "name"]) }
+* );
+*
+* publishEvent(new UserCreatedEvent(user));
+* ```
+*/
+function defineEvent(eventName, options = {}) {
+	return class AnnouncedEvent extends EventMessage {
+		eventName = eventName;
+		schema = options.schema;
+		constructor(data) {
+			super(data);
+		}
+		toJSON() {
+			if (!options.toJSON) return this.data;
+			return options.toJSON(this.data);
+		}
+	};
+}
+
+//#endregion
+export { EventMessage, defineEvent };
+//# sourceMappingURL=event-message.mjs.map

package/esm/herald/src/message-managers/event-message.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-message.mjs","names":[],"sources":["../../../../../../../../../herald/src/message-managers/event-message.ts"],"sourcesContent":["/**\n * This class is used to be part of the Herald Event Message Manager.\n * It should be used to trigger events to Either RabbitMQ or Kafka through Herald\n *\n * It's highly recommended using it instead of declaring manual channel namd and publishing data\n */\nimport { GenericObject } from \"@mongez/reinforcements\";\nimport { type ObjectValidator } from \"@warlock.js/seal\";\nimport { randomUUID } from \"crypto\";\n\nexport abstract class EventMessage<TPayload = Record<string, any>> {\n  /**\n   * Event Name\n   */\n  public abstract eventName: string;\n\n  /**\n   * Event version\n   */\n  public version?: number;\n\n  /**\n   * Additional metadata (if any)\n   */\n  public metadata?: Record<string, any>;\n\n  /**\n   * Event Message id\n   */\n  public messageId?: string;\n\n  /**\n   * Schema of payload that will be used to determine whether this event should be published\n   */\n  public schema?: ObjectValidator;\n\n  /**\n   * Data that will be sent with the event (Payload)\n   */\n  public toJSON(): TPayload {\n    if (!this.data) {\n      throw new Error(`no Data is defined for Event: ${this.eventName}`);\n    }\n\n    return this.data as TPayload;\n  }\n\n  public constructor(protected data?: TPayload) {}\n\n  /**\n   * Serialize the event to be ready for publishing.\n   * Delegates payload resolution to toJSON() — override toJSON() to customize.\n   *\n   * @throws Error if toJSON() throws (e.g. no data provided)\n   */\n  public serialize() {\n    const payload = this.toJSON();\n\n    return {\n      payload,\n      metadata: this.metadata,\n      messageId: this.messageId ?? randomUUID(),\n      eventName: this.eventName,\n      version: this.version,\n      occurredAt: new Date(),\n      __through: \"EventMessage\",\n    };\n  }\n}\n\ntype EventOptions<T> = {\n  /**\n   * Shapen the data that will be used\n   */\n  toJSON?: (data: T) => GenericObject;\n  /**\n   * Validation schema\n   */\n  schema?: ObjectValidator;\n};\n\n/**\n * Represents an EventMessage class constructor.\n *\n * @template TIncoming - The type of data accepted by the constructor\n * @template TOutgoing - The type of data returned by toJSON() (defaults to TIncoming)\n */\ntype EventMessageClass<TIncoming = Record<string, any>, TOutgoing = TIncoming> = new (\n  data?: TIncoming,\n) => EventMessage<TOutgoing>;\n\n/**\n * A shorthand to define an event without declaring an entire class.\n *\n * This factory function creates an EventMessage subclass that transforms\n * input data (IncomingData) into a different output format (OutgoingData).\n *\n * @template IncomingData - The type of data passed to the constructor\n * @template OutgoingData - The type of data returned by toJSON()\n *\n * @example\n * ```typescript\n * const UserCreatedEvent = defineEvent<User, { id: number; name: string }>(\n *   \"user.created\",\n *   { toJSON: (user) => user.only([\"id\", \"name\"]) }\n * );\n *\n * publishEvent(new UserCreatedEvent(user));\n * ```\n */\nexport function defineEvent<IncomingData = unknown, OutgoingData = unknown>(\n  eventName: string,\n  options: EventOptions<IncomingData> = {},\n): EventMessageClass<IncomingData, OutgoingData> {\n  // We need to use `any` here to bridge the IncomingData -> OutgoingData transformation\n  // The class accepts IncomingData in constructor but outputs OutgoingData via toJSON()\n  return class AnnouncedEvent extends EventMessage<OutgoingData> {\n    public eventName = eventName;\n    public schema = options.schema;\n\n    public constructor(data?: IncomingData) {\n      super(data as any);\n    }\n\n    public toJSON(): OutgoingData {\n      if (!options.toJSON) return this.data as OutgoingData;\n\n      return options.toJSON(this.data as IncomingData) as OutgoingData;\n    }\n  };\n}\n"],"mappings":";;;AAUA,IAAsB,eAAtB,MAAmE;CAqCpC;;;;CA5B7B,AAAO;;;;CAKP,AAAO;;;;CAKP,AAAO;;;;CAKP,AAAO;;;;CAKP,AAAO,SAAmB;EACxB,IAAI,CAAC,KAAK,MACR,MAAM,IAAI,MAAM,iCAAiC,KAAK,WAAW;EAGnE,OAAO,KAAK;CACd;CAEA,AAAO,YAAY,AAAU,MAAiB;EAAjB;CAAkB;;;;;;;CAQ/C,AAAO,YAAY;EAGjB,OAAO;GACL,SAHc,KAAK,OAGb;GACN,UAAU,KAAK;GACf,WAAW,KAAK,aAAa,WAAW;GACxC,WAAW,KAAK;GAChB,SAAS,KAAK;GACd,4BAAY,IAAI,KAAK;GACrB,WAAW;EACb;CACF;AACF;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,YACd,WACA,UAAsC,CAAC,GACQ;CAG/C,OAAO,MAAM,uBAAuB,aAA2B;EAC7D,AAAO,YAAY;EACnB,AAAO,SAAS,QAAQ;EAExB,AAAO,YAAY,MAAqB;GACtC,MAAM,IAAW;EACnB;EAEA,AAAO,SAAuB;GAC5B,IAAI,CAAC,QAAQ,QAAQ,OAAO,KAAK;GAEjC,OAAO,QAAQ,OAAO,KAAK,IAAoB;EACjD;CACF;AACF"}

package/esm/herald/src/message-managers/index.mjs

@@ -0,0 +1,4 @@
+import { EventConsumer, defineConsumer } from "./event-consumer.mjs";
+import { EventMessage, defineEvent } from "./event-message.mjs";
+
+export {  };

package/esm/herald/src/message-managers/prepare-consumer-subscription.mjs

@@ -0,0 +1,42 @@
+//#region ../herald/src/message-managers/prepare-consumer-subscription.ts
+function prepareConsumerSubscription(Consumer, onError) {
+	const callback = async (message, ctx) => {
+		const envelope = message.payload;
+		let eventPayload = envelope.payload;
+		if (envelope.version) {
+			if (!Consumer.isAcceptedVersion(Number(envelope.version))) {
+				ctx.ack();
+				return;
+			}
+		}
+		const consumer = new Consumer();
+		if (consumer.schema) {
+			const result = await consumer.validate(eventPayload);
+			if (!result || result.isValid === false) {
+				ctx.nack();
+				return;
+			}
+			eventPayload = result.data;
+		}
+		try {
+			await consumer.handle(eventPayload, {
+				payload: eventPayload,
+				eventName: Consumer.eventName,
+				messageId: message.metadata.messageId,
+				occurredAt: envelope.occurredAt ? new Date(envelope.occurredAt) : void 0,
+				metadata: envelope.metadata,
+				version: envelope.version,
+				message
+			});
+			ctx.ack();
+		} catch (error) {
+			await ctx.retry();
+			if (onError) onError(error, Consumer.eventName);
+		}
+	};
+	return callback;
+}
+
+//#endregion
+export { prepareConsumerSubscription };
+//# sourceMappingURL=prepare-consumer-subscription.mjs.map

package/esm/herald/src/message-managers/prepare-consumer-subscription.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare-consumer-subscription.mjs","names":[],"sources":["../../../../../../../../../herald/src/message-managers/prepare-consumer-subscription.ts"],"sourcesContent":["import type { MessageHandler } from \"./../types\";\r\nimport { EventConsumerClass } from \"./types\";\r\n\r\nexport function prepareConsumerSubscription(\r\n  Consumer: EventConsumerClass,\r\n  onError?: (error: unknown, consumerName: string) => void,\r\n) {\r\n  const callback: MessageHandler<any> = async (message, ctx) => {\r\n    const envelope = message.payload;\r\n    let eventPayload = envelope.payload;\r\n\r\n    if (envelope.version) {\r\n      if (!Consumer.isAcceptedVersion(Number(envelope.version))) {\r\n        ctx.ack(); // Acknowledge but don't process\r\n        return;\r\n      }\r\n    }\r\n\r\n    const consumer = new Consumer();\r\n\r\n    if (consumer.schema) {\r\n      const result = await consumer.validate(eventPayload);\r\n      if (!result || result.isValid === false) {\r\n        ctx.nack();\r\n        return;\r\n      }\r\n\r\n      eventPayload = result.data;\r\n    }\r\n    try {\r\n      await consumer.handle(eventPayload, {\r\n        payload: eventPayload,\r\n        eventName: Consumer.eventName,\r\n        messageId: message.metadata.messageId!,\r\n        occurredAt: envelope.occurredAt ? new Date(envelope.occurredAt) : undefined,\r\n        metadata: envelope.metadata,\r\n        version: envelope.version,\r\n        message,\r\n      });\r\n      ctx.ack(); // Auto-ack on success?\r\n    } catch (error) {\r\n      // Bounded retry instead of an unconditional requeue: a message that\r\n      // reliably throws (bad payload, a handler bug, a downstream outage)\r\n      // would otherwise be nack+requeued forever, pinning the consumer in a\r\n      // hot loop. `ctx.retry()` caps redelivery and dead-letters/drops (with\r\n      // a loud log) once the cap is hit.\r\n      await ctx.retry();\r\n      if (onError) {\r\n        onError(error, Consumer.eventName);\r\n      }\r\n    }\r\n  };\r\n\r\n  return callback;\r\n}\r\n"],"mappings":";AAGA,SAAgB,4BACd,UACA,SACA;CACA,MAAM,WAAgC,OAAO,SAAS,QAAQ;EAC5D,MAAM,WAAW,QAAQ;EACzB,IAAI,eAAe,SAAS;EAE5B,IAAI,SAAS,SACX;OAAI,CAAC,SAAS,kBAAkB,OAAO,SAAS,OAAO,CAAC,GAAG;IACzD,IAAI,IAAI;IACR;GACF;;EAGF,MAAM,WAAW,IAAI,SAAS;EAE9B,IAAI,SAAS,QAAQ;GACnB,MAAM,SAAS,MAAM,SAAS,SAAS,YAAY;GACnD,IAAI,CAAC,UAAU,OAAO,YAAY,OAAO;IACvC,IAAI,KAAK;IACT;GACF;GAEA,eAAe,OAAO;EACxB;EACA,IAAI;GACF,MAAM,SAAS,OAAO,cAAc;IAClC,SAAS;IACT,WAAW,SAAS;IACpB,WAAW,QAAQ,SAAS;IAC5B,YAAY,SAAS,aAAa,IAAI,KAAK,SAAS,UAAU,IAAI;IAClE,UAAU,SAAS;IACnB,SAAS,SAAS;IAClB;GACF,CAAC;GACD,IAAI,IAAI;EACV,SAAS,OAAO;GAMd,MAAM,IAAI,MAAM;GAChB,IAAI,SACF,QAAQ,OAAO,SAAS,SAAS;EAErC;CACF;CAEA,OAAO;AACT"}

package/esm/herald/src/use-case-broadcast.mjs

@@ -0,0 +1,30 @@
+import { herald } from "./utils/connect-to-broker.mjs";
+
+//#region ../herald/src/use-case-broadcast.ts
+/**
+* Channel adapter that publishes use-case broadcast events onto a herald broker.
+*
+* Register it in the use-cases config so successful use cases fan out to the bus:
+*
+* @example
+* // src/config/use-cases.ts
+* import { heraldBroadcast } from "@warlock.js/herald";
+*
+* export default {
+*   broadcast: {
+*     enabled: true,
+*     channels: [heraldBroadcast({ broker: "default" })],
+*   },
+* } satisfies UseCaseConfigurations;
+*
+* @param options - Optional broker name (defaults to the default broker)
+*/
+function heraldBroadcast(options) {
+	return { async broadcast(event) {
+		await herald(options?.broker).channel(event.event).publish(event.payload);
+	} };
+}
+
+//#endregion
+export { heraldBroadcast };
+//# sourceMappingURL=use-case-broadcast.mjs.map

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

@@ -0,0 +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"}