rbtmq-resilience 0.1.0-rc.1

package/README.md

@@ -0,0 +1,609 @@
+# rbtmq-resilience
+
+Reusable RabbitMQ resilience library for TypeScript microservices.
+
+`rbtmq-resilience` helps services publish and consume RabbitMQ messages with a consistent topology, retries, poison-message handling, inbox/outbox persistence, and optional health endpoints.
+
+It is designed for services that need:
+
+- Integration events through a `fanout` exchange.
+- Tactical/internal events through a `topic` exchange.
+- Commands, retries, and error routing through a `direct` exchange.
+- Immediate retries in memory.
+- Delayed retries with RabbitMQ TTL and dead-letter routing.
+- Inbox idempotency per `message_id + handler_name`.
+- Outbox publishing backed by MySQL and Drizzle ORM.
+- Runtime health and resilience metrics through Hono.
+
+All names in this README are fictional examples. Replace `commerce`, `orders`, `checkout`, and `app.*` with names that match your own service and RabbitMQ topology.
+
+## Installation
+
+```bash
+pnpm add rbtmq-resilience@rc
+```
+
+or with npm:
+
+```bash
+npm install rbtmq-resilience@rc
+```
+
+## Exchange Model
+
+Use three exchange names with three different responsibilities:
+
+```txt
+integration exchange   fanout   public integration events
+tactical exchange      topic    tactical/internal events
+direct exchange        direct   commands, retries, and error queues
+```
+
+Example:
+
+```env
+RABBIT_EXCHANGE=app.integration
+RABBIT_TYPE_EXCHANGE=fanout
+
+RABBIT_TACTICAL_EXCHANGE=app.tactical
+RABBIT_TACTICAL_TYPE_EXCHANGE=topic
+
+RABBIT_DIRECT_EXCHANGE=app.direct
+RABBIT_TYPE_DIRECT_EXCHANGE=direct
+```
+
+RabbitMQ does not allow an existing exchange to change type. If `app.integration` already exists as `fanout`, do not reuse it as `topic`; create a separate tactical exchange such as `app.tactical`.
+
+## Queue Naming
+
+Instead of storing full queue names in `.env`, store the parts that identify the service:
+
+```env
+RABBIT_DOMAIN=commerce
+RABBIT_SUBDOMAIN=orders
+RABBIT_BOUNDED_CONTEXT=checkout
+```
+
+Then generate names with `RbtmqNaming`:
+
+```ts
+import { QueueNamePartsDto, RbtmqNaming } from "rbtmq-resilience";
+
+const eventNames = RbtmqNaming.queueNames(
+    new QueueNamePartsDto(
+        "commerce",
+        "orders",
+        "checkout",
+        "events",
+    ),
+);
+
+console.log(eventNames.queue);
+// commerce.orders.checkout.events
+
+console.log(eventNames.retryQueue);
+// commerce.orders.checkout.events-retry
+```
+
+For topic bindings:
+
+```ts
+const bindingPattern = RbtmqNaming.tacticalBindingPattern(
+    "commerce",
+    "orders",
+    "checkout",
+);
+
+console.log(bindingPattern);
+// commerce.orders.checkout.#
+```
+
+## Example Environment Variables
+
+```env
+PORT=3001
+
+DB_HOST=localhost
+DB_PORT=3306
+DB_USER=root
+DB_PASSWORD=secret
+DB_NAME=service_db
+
+RABBIT_PROTOCOL=amqp
+RABBIT_HOSTNAME=localhost
+RABBIT_PORT=5672
+RABBIT_USERNAME=guest
+RABBIT_PASSWORD=guest
+RABBIT_VHOST=/
+
+RABBIT_DOMAIN=commerce
+RABBIT_SUBDOMAIN=orders
+RABBIT_BOUNDED_CONTEXT=checkout
+
+RABBIT_EXCHANGE=app.integration
+RABBIT_TYPE_EXCHANGE=fanout
+
+RABBIT_TACTICAL_EXCHANGE=app.tactical
+RABBIT_TACTICAL_TYPE_EXCHANGE=topic
+
+RABBIT_DIRECT_EXCHANGE=app.direct
+RABBIT_TYPE_DIRECT_EXCHANGE=direct
+
+RABBIT_PREFETCH=1
+RABBIT_RETRY_ENDPOINT=checkout-service
+RABBIT_MESSAGE_TTL=10000
+
+RABBIT_DEAD_LETTER_QUEUE=commerce.orders.checkout.error
+RABBIT_DEAD_LETTER_ROUTING_KEY=commerce.orders.checkout.error
+
+RABBIT_HEALTH_PORT=3002
+```
+
+Use only the consumer blocks your service needs:
+
+```txt
+Only integration events       configure eventsToProcess
+Integration + topic events    configure eventsToProcess and tacticalEvents
+Commands only                 configure commands and keep eventsToProcess as []
+Retries and error queues      always use the direct exchange internally
+```
+
+## Register Integration Event Handlers
+
+`eventsToProcess` is used for messages consumed from the integration/fanout flow.
+
+```ts
+import { EventProcessConfig, RabbitMQMessageDto } from "rbtmq-resilience";
+
+export const eventsToProcess: EventProcessConfig[] = [
+    {
+        eventType: "commerce.orders.order_created",
+        processes: [
+            {
+                processName: "create-local-order",
+                processFunction: async (event: RabbitMQMessageDto) => {
+                    const payload = JSON.parse(event.content.toString("utf8"));
+                    console.log(payload);
+                },
+            },
+        ],
+    },
+];
+```
+
+The library stores each successful handler execution in `inbox`, using `message_id + handler_name`, so duplicate messages are not processed twice by the same handler.
+
+## Register Tactical Topic Handlers
+
+Use `tacticalEvents` when a service consumes topic events.
+
+```ts
+import { EventProcessConfig, RabbitMQMessageDto } from "rbtmq-resilience";
+
+export const tacticalEventsToProcess: EventProcessConfig[] = [
+    {
+        eventType: "commerce.orders.payment_authorized",
+        processes: [
+            {
+                processName: "confirm-checkout-payment",
+                processFunction: async (event: RabbitMQMessageDto) => {
+                    const payload = JSON.parse(event.content.toString("utf8"));
+                    console.log(payload);
+                },
+            },
+        ],
+    },
+];
+```
+
+The tactical queue will have two useful bindings:
+
+```txt
+app.tactical   commerce.orders.checkout.#
+app.direct     commerce.orders.checkout.tactical-events
+```
+
+The `topic` binding is for business messages. The `direct` binding is internal and allows delayed retry queues to route failed messages back to the primary queue.
+
+RabbitMQ also shows a default exchange binding for every queue. That is created automatically by RabbitMQ and can be ignored.
+
+## Configure the Runtime
+
+Create a RabbitMQ module in your service, for example `src/infrastructure/rabbitmq/rabbitmq.ts`.
+
+```ts
+import env from "@/shared/env";
+import {
+    QueueNamePartsDto,
+    RabbitMQResilience,
+    RbtmqConsumerConfigDto,
+    RbtmqNaming,
+    RbtmqResilienceConfig,
+} from "rbtmq-resilience";
+import { eventsToProcess } from "./eventsToProcess";
+import { tacticalEventsToProcess } from "./tacticalEventsToProcess";
+
+const eventNames = RbtmqNaming.queueNames(
+    new QueueNamePartsDto(
+        env.RABBIT_DOMAIN,
+        env.RABBIT_SUBDOMAIN,
+        env.RABBIT_BOUNDED_CONTEXT,
+        "events",
+    ),
+);
+
+const tacticalEventNames = RbtmqNaming.queueNames(
+    new QueueNamePartsDto(
+        env.RABBIT_DOMAIN,
+        env.RABBIT_SUBDOMAIN,
+        env.RABBIT_BOUNDED_CONTEXT,
+        "tactical-events",
+    ),
+);
+
+export const rbtmqResilienceConfig: RbtmqResilienceConfig = {
+    rabbitMQConfigConnect: {
+        protocol: env.RABBIT_PROTOCOL,
+        hostname: env.RABBIT_HOSTNAME,
+        port: Number(env.RABBIT_PORT),
+        username: env.RABBIT_USERNAME,
+        password: env.RABBIT_PASSWORD,
+        vhost: env.RABBIT_VHOST,
+    },
+
+    queue: eventNames.queue,
+    routingKey: eventNames.routingKey,
+    exchange: env.RABBIT_EXCHANGE,
+    typeExchange: env.RABBIT_TYPE_EXCHANGE,
+
+    tacticalExchange: env.RABBIT_TACTICAL_EXCHANGE,
+    tacticalTypeExchange: env.RABBIT_TACTICAL_TYPE_EXCHANGE,
+
+    directExchange: env.RABBIT_DIRECT_EXCHANGE,
+    typeDirectExchange: env.RABBIT_TYPE_DIRECT_EXCHANGE,
+
+    prefetch: env.RABBIT_PREFETCH,
+    retryQueue: eventNames.retryQueue,
+    retryRoutingKey: eventNames.retryRoutingKey,
+    retryEndpoint: env.RABBIT_RETRY_ENDPOINT,
+    deadLetterQueue: env.RABBIT_DEAD_LETTER_QUEUE,
+    deadLetterRoutingKey: env.RABBIT_DEAD_LETTER_ROUTING_KEY,
+    messageTTL: env.RABBIT_MESSAGE_TTL,
+
+    eventResilienceHandlerConfig: {
+        immediateRetryAttempts: 5,
+        delayedRetryAttempts: 3,
+        delayInMs: 1000,
+    },
+
+    eventsToProcess,
+
+    tacticalEvents: new RbtmqConsumerConfigDto(
+        tacticalEventNames.queue,
+        "tacticalEvents",
+        tacticalEventNames.queue,
+        tacticalEventNames.routingKey,
+        tacticalEventNames.retryQueue,
+        tacticalEventNames.retryRoutingKey,
+        `${tacticalEventNames.queue}-error`,
+        `${tacticalEventNames.routingKey}-error`,
+        env.RABBIT_MESSAGE_TTL,
+        tacticalEventsToProcess,
+        env.RABBIT_PREFETCH,
+        env.RABBIT_TACTICAL_EXCHANGE,
+        RbtmqNaming.tacticalBindingPattern(
+            env.RABBIT_DOMAIN,
+            env.RABBIT_SUBDOMAIN,
+            env.RABBIT_BOUNDED_CONTEXT,
+        ),
+    ),
+
+    mysql: {
+        host: env.DB_HOST,
+        port: Number(env.DB_PORT),
+        user: env.DB_USER,
+        password: env.DB_PASSWORD,
+        database: env.DB_NAME,
+    },
+
+    hono: {
+        enabled: true,
+        port: env.RABBIT_HEALTH_PORT,
+    },
+};
+
+export const RabbitMQR = RabbitMQResilience.initialize(rbtmqResilienceConfig);
+```
+
+If a service does not need topic events, omit `tacticalEvents`. If it does not need commands, omit `commands`. The integration event consumer still uses the top-level `queue`, `retryQueue`, and `eventsToProcess` fields.
+
+## Start the Runtime
+
+Call `init()` during service startup.
+
+```ts
+import { RabbitMQR } from "@/infrastructure/rabbitmq";
+
+await RabbitMQR.init();
+```
+
+`init()` will:
+
+- Connect to MySQL.
+- Create or verify `inbox` and `outbox`.
+- Connect to RabbitMQ.
+- Declare exchanges, queues, retry queues, error queues, and bindings.
+- Start configured consumers.
+- Start the outbox relay unless disabled.
+- Start Hono health endpoints if enabled.
+
+Use `stop()` during graceful shutdown:
+
+```ts
+await RabbitMQR.stop();
+```
+
+## Publish Integration Events
+
+Integration events are published to the configured `fanout` exchange.
+
+```ts
+import { RabbitMQR } from "@/infrastructure/rabbitmq";
+
+await RabbitMQR.publishEvent({
+    type: "commerce.orders.order_created",
+    payload: {
+        orderId: "order-123",
+        receivedAt: new Date().toISOString(),
+    },
+});
+```
+
+The routing key is optional for fanout exchanges because RabbitMQ ignores it for delivery.
+
+The library also supports the legacy-style `RabbitMQMessageDto`:
+
+```ts
+import { RabbitMQMessageDto } from "rbtmq-resilience";
+import {
+    MessageFieldsDto,
+    MessagePropertiesDto,
+} from "rbtmq-resilience/domain/dtos/eventManager";
+import { RabbitMQR, rbtmqResilienceConfig } from "@/infrastructure/rabbitmq";
+
+const message = new RabbitMQMessageDto(
+    Buffer.from(JSON.stringify({ orderId: "order-123" })),
+    new MessageFieldsDto(
+        0,
+        false,
+        rbtmqResilienceConfig.exchange,
+        rbtmqResilienceConfig.routingKey,
+    ),
+    new MessagePropertiesDto(
+        "application/json",
+        "utf-8",
+        undefined,
+        2,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        crypto.randomUUID(),
+        "commerce.orders.order_created",
+        undefined,
+        "commerce.orders",
+    ),
+);
+
+await RabbitMQR.publishEvent(message);
+```
+
+## Publish Tactical Topic Events
+
+Topic events require a routing key.
+
+```ts
+import { QueueNamePartsDto, RbtmqNaming } from "rbtmq-resilience";
+import { RabbitMQR } from "@/infrastructure/rabbitmq";
+
+await RabbitMQR.publishTacticalEvent({
+    type: "commerce.orders.payment_authorized",
+    routingKey: RbtmqNaming.tacticalRoutingKey(
+        new QueueNamePartsDto(
+            "commerce",
+            "orders",
+            "checkout",
+        ),
+    ),
+    payload: {
+        orderId: "order-123",
+    },
+});
+```
+
+With the binding pattern `commerce.orders.checkout.#`, this message will be delivered to that service tactical queue.
+
+## Send Commands
+
+Commands use the `direct` exchange and must provide an exact routing key.
+
+```ts
+await RabbitMQR.sendCommand({
+    type: "commerce.orders.reserve_stock",
+    routingKey: "commerce.orders.checkout.commands",
+    payload: {
+        orderId: "order-123",
+    },
+});
+```
+
+Use commands when one specific service/queue should receive the message.
+
+## Outbox
+
+Use the outbox when your service must persist a message before publishing it.
+
+```ts
+const messageId = await RabbitMQR.saveOutboxMessage({
+    type: "commerce.orders.order_created",
+    body: {
+        orderId: "order-123",
+    },
+    exchange: "app.integration",
+    routingKey: "",
+    headers: {
+        source: "checkout-service",
+    },
+});
+```
+
+The relay runs automatically unless disabled:
+
+```ts
+outbox: {
+    enabled: true,
+    batchSize: 50,
+    pollingIntervalMs: 5000,
+}
+```
+
+You can also dispatch manually:
+
+```ts
+const sent = await RabbitMQR.dispatchOutbox(50);
+console.log(sent);
+```
+
+## Database
+
+The library uses MySQL through Drizzle ORM and creates/verifies two tables at startup:
+
+```txt
+inbox
+outbox
+```
+
+`inbox` is used for idempotent consumption. `outbox` is used for reliable publishing.
+
+You can import the migration SQL if you want to include it in your own migration flow:
+
+```ts
+import { mysqlMigration } from "rbtmq-resilience";
+```
+
+A service may already have its own database configuration. That is fine: pass the same MySQL connection settings, or pass a Drizzle database instance through `db`. The library only manages its own `inbox` and `outbox` tables.
+
+## Health and Metrics
+
+When Hono is enabled:
+
+```ts
+hono: {
+    enabled: true,
+    port: 3002,
+}
+```
+
+The library exposes:
+
+```txt
+GET /health
+GET /ready
+GET /metrics/resilience
+GET /metrics/resilience/failed
+```
+
+Use a port different from your HTTP API port.
+
+## Retry Behavior
+
+For each message:
+
+1. The library reads `message_id` and `type` from AMQP properties or headers.
+2. The message body is parsed as JSON.
+3. Matching handlers are selected by `eventType`.
+4. `inbox` is checked before each handler.
+5. The handler runs with immediate retries.
+6. If it succeeds, `inbox` is marked and the message is acknowledged.
+7. If it fails and delayed attempts remain, the message is sent to the retry queue.
+8. If validation fails or attempts are exhausted, it is sent to the error queue.
+
+The message is acknowledged only after success or after it has been safely published to retry/error. If publishing to retry/error fails, the message is nacked and requeued.
+
+## Troubleshooting
+
+**PRECONDITION_FAILED - inequivalent arg 'type' for exchange**
+
+RabbitMQ already has an exchange with that name but a different type.
+
+Example:
+
+```txt
+received 'topic' but current is 'fanout'
+```
+
+Fix it by using different exchange names:
+
+```env
+RABBIT_EXCHANGE=app.integration
+RABBIT_TYPE_EXCHANGE=fanout
+
+RABBIT_TACTICAL_EXCHANGE=app.tactical
+RABBIT_TACTICAL_TYPE_EXCHANGE=topic
+
+RABBIT_DIRECT_EXCHANGE=app.direct
+RABBIT_TYPE_DIRECT_EXCHANGE=direct
+```
+
+or delete/recreate the exchange in RabbitMQ if the existing type is wrong.
+
+**Why does my queue have two bindings?**
+
+That is expected.
+
+```txt
+tactical exchange   topic routing for business messages
+direct exchange     internal routing for retry/error flow
+```
+
+RabbitMQ also creates a default exchange binding automatically for every queue.
+
+**EADDRINUSE on startup**
+
+Your service API and the library health server are trying to use the same port. Configure a separate health port:
+
+```env
+PORT=3001
+RABBIT_HEALTH_PORT=3002
+```
+
+```ts
+hono: {
+    enabled: true,
+    port: env.RABBIT_HEALTH_PORT,
+}
+```
+
+**pnpm minimum release age blocks alpha versions**
+
+If your workspace uses `minimumReleaseAge`, allow this package explicitly:
+
+```yaml
+minimumReleaseAgeExclude:
+  - rbtmq-resilience
+```
+
+## Build
+
+```bash
+bun run typecheck
+bun run build
+```
+
+Before publishing:
+
+```bash
+npm pack --dry-run
+npm publish --tag alpha
+```

package/dist/application/configMapper.d.ts

@@ -0,0 +1,4 @@
+import type { RbtmqResilienceConfigDto as RbtmqResilienceConfig, RbtmqResilienceRuntimeConfigDto as RbtmqResilienceRuntimeConfig } from "../domain/dtos/config.dto";
+export declare function isServiceConfig(config: RbtmqResilienceConfig | RbtmqResilienceRuntimeConfig): config is RbtmqResilienceConfig;
+export declare function toRuntimeConfig(config: RbtmqResilienceConfig): RbtmqResilienceRuntimeConfig;
+//# sourceMappingURL=configMapper.d.ts.map

package/dist/application/configMapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configMapper.d.ts","sourceRoot":"","sources":["../../src/application/configMapper.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAKV,wBAAwB,IAAI,qBAAqB,EACjD,+BAA+B,IAAI,4BAA4B,EAEhE,MAAM,2BAA2B,CAAC;AAEnC,wBAAgB,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,4BAA4B,GAAG,MAAM,IAAI,qBAAqB,CAE7H;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,4BAA4B,CAkD3F"}

package/dist/application/failedMessageMonitor.d.ts

@@ -0,0 +1,10 @@
+import { FailedMessageDto } from "../domain/dtos/metrics.dto";
+import type { HandlerFailureDto, ParsedMessageDto } from "../domain/dtos/messageProcessing.dto";
+export declare class FailedMessageMonitor {
+    private readonly maxMessages;
+    private readonly messages;
+    constructor(maxMessages?: number);
+    record(parsed: ParsedMessageDto, consumerName: string, failures: HandlerFailureDto[]): void;
+    list(): FailedMessageDto[];
+}
+//# sourceMappingURL=failedMessageMonitor.d.ts.map

package/dist/application/failedMessageMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failedMessageMonitor.d.ts","sourceRoot":"","sources":["../../src/application/failedMessageMonitor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAEhG,qBAAa,oBAAoB;IAGnB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAFxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0B;gBAEtB,WAAW,SAAM;IAEvC,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,EAAE,GAAG,IAAI;IAiB3F,IAAI,IAAI,gBAAgB,EAAE;CAGlC"}

package/dist/application/resilience.d.ts

@@ -0,0 +1,44 @@
+import { RabbitMQMessageDto } from "../domain/dtos/eventManager.dto";
+import type { RbtmqResilienceConfigDto as RbtmqResilienceConfig, RbtmqResilienceRuntimeConfigDto as RbtmqResilienceRuntimeConfig } from "../domain/dtos/config.dto";
+import { ResilienceMetricsDto } from "../domain/dtos/metrics.dto";
+import type { OutboxInputDto as OutboxInput, PublishEnvelopeDto as PublishEnvelope } from "../domain/dtos/publish.dto";
+export declare class RabbitMQResilience {
+    private connection?;
+    private channel?;
+    private db?;
+    private inboxRepository?;
+    private outboxRepository?;
+    private readonly databaseService;
+    private readonly rabbitMQService;
+    private readonly healthServer;
+    private readonly failedMessageMonitor;
+    private outboxRelayTimer?;
+    private readonly metrics;
+    private readonly config;
+    constructor(config: RbtmqResilienceConfig | RbtmqResilienceRuntimeConfig);
+    static initialize(config: RbtmqResilienceConfig | RbtmqResilienceRuntimeConfig): RabbitMQResilience;
+    init(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    declareTopology(): Promise<void>;
+    publishEvent(envelope: PublishEnvelope | RabbitMQMessageDto): Promise<string>;
+    publishTacticalEvent(envelope: PublishEnvelope): Promise<string>;
+    sendCommand(envelope: PublishEnvelope): Promise<string>;
+    saveOutboxMessage(input: OutboxInput): Promise<string>;
+    dispatchOutbox(batchSize?: number): Promise<number>;
+    getMetrics(): ResilienceMetricsDto;
+    isReady(): Promise<boolean>;
+    private ensureDatabase;
+    private ensureChannel;
+    private startConsumers;
+    private startConsumer;
+    private processMessage;
+    private parseMessage;
+    private runWithImmediateRetries;
+    private requireOutboxRepository;
+    private startOutboxRelay;
+    private startHono;
+}
+export declare function createRabbitMqResilience(config: RbtmqResilienceConfig | RbtmqResilienceRuntimeConfig): RabbitMQResilience;
+export declare const RabbitMqResilience: typeof RabbitMQResilience;
+//# sourceMappingURL=resilience.d.ts.map

package/dist/application/resilience.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resilience.d.ts","sourceRoot":"","sources":["../../src/application/resilience.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AASrE,OAAO,KAAK,EAEV,wBAAwB,IAAI,qBAAqB,EACjD,+BAA+B,IAAI,4BAA4B,EAChE,MAAM,2BAA2B,CAAC;AAKnC,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EACV,cAAc,IAAI,WAAW,EAC7B,kBAAkB,IAAI,eAAe,EACtC,MAAM,4BAA4B,CAAC;AAUpC,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,UAAU,CAAC,CAAe;IAClC,OAAO,CAAC,OAAO,CAAC,CAAU;IAC1B,OAAO,CAAC,EAAE,CAAC,CAAqB;IAChC,OAAO,CAAC,eAAe,CAAC,CAAkB;IAC1C,OAAO,CAAC,gBAAgB,CAAC,CAAmB;IAC5C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;IAClD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;IAClD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA8B;IACnE,OAAO,CAAC,gBAAgB,CAAC,CAAiC;IAC1D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8B;IAEtD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+B;gBAE1C,MAAM,EAAE,qBAAqB,GAAG,4BAA4B;WAgB1D,UAAU,CAAC,MAAM,EAAE,qBAAqB,GAAG,4BAA4B,GAAG,kBAAkB;IAI7F,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAStB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAarB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAIhC,YAAY,CAAC,QAAQ,EAAE,eAAe,GAAG,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;IAI7E,oBAAoB,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC;IAIhE,WAAW,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC;IAIvD,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAItD,cAAc,CAAC,SAAS,SAAuC,GAAG,OAAO,CAAC,MAAM,CAAC;IA0BvF,UAAU,IAAI,oBAAoB;IAW5B,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;YAU1B,cAAc;YAUd,aAAa;YAwBb,cAAc;YAMd,aAAa;YASb,cAAc;IAiG5B,OAAO,CAAC,YAAY;YAmCN,uBAAuB;IAarC,OAAO,CAAC,uBAAuB;IAO/B,OAAO,CAAC,gBAAgB;IAexB,OAAO,CAAC,SAAS;CAGlB;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,qBAAqB,GAAG,4BAA4B,GAAG,kBAAkB,CAEzH;AAED,eAAO,MAAM,kBAAkB,2BAAqB,CAAC"}