@nebutra/queue 0.1.0 → 0.1.2

package/dist/providers/bullmq.js

@@ -0,0 +1,258 @@
+import { logger } from "@nebutra/logger";
+import { Queue, Worker } from "bullmq";
+import IORedis from "ioredis";
+export function toBullMQDeadLetterJob(queue, job) {
+    const maxRetries = job.opts.attempts ?? job.data.options?.maxRetries ?? 3;
+    if (job.attemptsMade < maxRetries)
+        return undefined;
+    return {
+        id: job.id ?? job.data.id,
+        queue,
+        type: job.data.type,
+        originalJob: job.data,
+        attempts: job.attemptsMade,
+        maxRetries,
+        failedReason: job.failedReason ?? "Job failed without a provider reason",
+        provider: "bullmq",
+        failedAt: new Date(job.finishedOn ?? Date.now()).toISOString(),
+    };
+}
+// BullMQ Provider — self-hosted Redis queue backend
+// =============================================================================
+// Uses BullMQ (the successor to Bull) for job queuing over a standard Redis
+// instance. Ideal for customers who self-host Redis or need features like
+// priority queues, rate limiting, and the Bull Board dashboard.
+//
+// Architecture:
+//   enqueue()        →  Redis LPUSH via BullMQ Queue
+//   registerHandler  →  BullMQ Worker (long-polling BRPOPLPUSH)
+//   getJobStatus     →  Redis HGET on the job hash
+// =============================================================================
+export class BullMQProvider {
+    name = "bullmq";
+    connection;
+    queues = new Map();
+    workers = new Map();
+    handlers = new Map();
+    prefix;
+    concurrency;
+    constructor(config) {
+        const redisUrl = config.redisUrl ?? process.env.REDIS_URL;
+        if (!redisUrl) {
+            throw new Error("Redis URL not configured. Set REDIS_URL env var or pass `redisUrl` in config.");
+        }
+        this.prefix = config.prefix ?? "nebutra:queue";
+        this.concurrency = config.concurrency ?? 5;
+        this.connection = new IORedis(redisUrl, {
+            maxRetriesPerRequest: null, // Required by BullMQ
+            enableReadyCheck: false,
+            lazyConnect: true,
+        });
+        this.connection.on("error", (err) => {
+            logger.error("[queue:bullmq] Redis connection error", {
+                error: err.message,
+            });
+        });
+        logger.info("[queue:bullmq] Provider initialised", {
+            prefix: this.prefix,
+            concurrency: this.concurrency,
+        });
+    }
+    // ── Internal helpers ────────────────────────────────────────────────────
+    getOrCreateQueue(queueName) {
+        let queue = this.queues.get(queueName);
+        if (!queue) {
+            queue = new Queue(queueName, {
+                connection: this.connection.duplicate(),
+                prefix: this.prefix,
+                defaultJobOptions: {
+                    attempts: 3,
+                    backoff: { type: "exponential", delay: 1000 },
+                    removeOnComplete: { count: 1000 },
+                    removeOnFail: { count: 5000 },
+                },
+            });
+            this.queues.set(queueName, queue);
+        }
+        return queue;
+    }
+    // ── Enqueue ─────────────────────────────────────────────────────────────
+    async enqueue(job) {
+        const queue = this.getOrCreateQueue(job.queue);
+        try {
+            const bullJob = await queue.add(job.type, job, {
+                jobId: job.id,
+                ...(job.options?.delaySec ? { delay: job.options.delaySec * 1000 } : {}),
+                attempts: job.options?.maxRetries ?? 3,
+                ...(job.options?.priority !== undefined ? { priority: job.options.priority } : {}),
+                ...(job.options?.cron ? { repeat: { pattern: job.options.cron } } : {}),
+            });
+            logger.info("[queue:bullmq] Job enqueued", {
+                jobId: bullJob.id,
+                queue: job.queue,
+                type: job.type,
+            });
+            return {
+                jobId: bullJob.id ?? job.id,
+                accepted: true,
+                provider: "bullmq",
+            };
+        }
+        catch (error) {
+            logger.error("[queue:bullmq] Failed to enqueue job", {
+                jobId: job.id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async enqueueBatch(jobs) {
+        // Group jobs by queue name for efficient bulk add
+        const grouped = new Map();
+        for (const job of jobs) {
+            const list = grouped.get(job.queue) ?? [];
+            list.push(job);
+            grouped.set(job.queue, list);
+        }
+        const results = [];
+        for (const [queueName, queueJobs] of grouped) {
+            const queue = this.getOrCreateQueue(queueName);
+            const bulkData = queueJobs.map((job) => ({
+                name: job.type,
+                data: job,
+                opts: {
+                    jobId: job.id,
+                    ...(job.options?.delaySec ? { delay: job.options.delaySec * 1000 } : {}),
+                    attempts: job.options?.maxRetries ?? 3,
+                    ...(job.options?.priority !== undefined ? { priority: job.options.priority } : {}),
+                },
+            }));
+            const bullJobs = await queue.addBulk(bulkData);
+            for (let i = 0; i < bullJobs.length; i++) {
+                results.push({
+                    jobId: bullJobs[i]?.id ?? queueJobs[i]?.id ?? "",
+                    accepted: true,
+                    provider: "bullmq",
+                });
+            }
+        }
+        logger.info("[queue:bullmq] Batch enqueued", { count: jobs.length });
+        return results;
+    }
+    // ── Handler Registration ────────────────────────────────────────────────
+    registerHandler(queue, type, handler) {
+        const key = `${queue}:${type}`;
+        this.handlers.set(key, handler);
+        // Create or update the worker for this queue
+        this.ensureWorker(queue);
+        logger.info("[queue:bullmq] Handler registered", { key });
+    }
+    ensureWorker(queueName) {
+        if (this.workers.has(queueName))
+            return;
+        const worker = new Worker(queueName, async (bullJob) => {
+            const payload = bullJob.data;
+            const key = `${payload.queue}:${payload.type}`;
+            const handler = this.handlers.get(key);
+            if (!handler) {
+                logger.warn("[queue:bullmq] No handler registered for job type", {
+                    key,
+                    jobId: payload.id,
+                });
+                throw new Error(`No handler registered for ${key}`);
+            }
+            await handler(payload);
+        }, {
+            connection: this.connection.duplicate(),
+            prefix: this.prefix,
+            concurrency: this.concurrency,
+            removeOnComplete: { count: 1000 },
+            removeOnFail: { count: 5000 },
+        });
+        worker.on("completed", (job) => {
+            logger.info("[queue:bullmq] Job completed", {
+                jobId: job.id,
+                queue: queueName,
+            });
+        });
+        worker.on("failed", (job, err) => {
+            logger.error("[queue:bullmq] Job failed", {
+                jobId: job?.id,
+                queue: queueName,
+                error: err.message,
+                attempts: job?.attemptsMade,
+            });
+        });
+        worker.on("error", (err) => {
+            logger.error("[queue:bullmq] Worker error", {
+                queue: queueName,
+                error: err.message,
+            });
+        });
+        this.workers.set(queueName, worker);
+    }
+    // ── Job Status ──────────────────────────────────────────────────────────
+    async getJobStatus(jobId, queue) {
+        const q = this.queues.get(queue);
+        if (!q)
+            return undefined;
+        const bullJob = await q.getJob(jobId);
+        if (!bullJob)
+            return undefined;
+        const state = await bullJob.getState();
+        const statusMap = {
+            completed: "completed",
+            failed: "failed",
+            delayed: "delayed",
+            active: "active",
+            waiting: "waiting",
+            "waiting-children": "waiting",
+            prioritized: "pending",
+            unknown: "pending",
+        };
+        return {
+            id: bullJob.id ?? jobId,
+            queue,
+            status: statusMap[state] ?? "pending",
+            attempts: bullJob.attemptsMade,
+            maxRetries: bullJob.opts.attempts ?? 3,
+            ...(bullJob.failedReason ? { failedReason: bullJob.failedReason } : {}),
+            createdAt: new Date(bullJob.timestamp).toISOString(),
+            ...(bullJob.processedOn ? { processedAt: new Date(bullJob.processedOn).toISOString() } : {}),
+            ...(bullJob.finishedOn ? { completedAt: new Date(bullJob.finishedOn).toISOString() } : {}),
+        };
+    }
+    async getDeadLetteredJobs(queue) {
+        const entries = queue !== undefined ? [[queue, this.getOrCreateQueue(queue)]] : this.queues;
+        const deadLetters = [];
+        for (const [queueName, q] of entries) {
+            const failedJobs = await q.getFailed(0, -1);
+            for (const failedJob of failedJobs) {
+                const deadLetter = toBullMQDeadLetterJob(queueName, failedJob);
+                if (deadLetter)
+                    deadLetters.push(deadLetter);
+            }
+        }
+        return deadLetters;
+    }
+    // ── Lifecycle ───────────────────────────────────────────────────────────
+    async close() {
+        const closeTasks = [];
+        for (const [name, worker] of this.workers) {
+            closeTasks.push(worker.close().then(() => {
+                logger.info("[queue:bullmq] Worker closed", { queue: name });
+            }));
+        }
+        for (const [name, queue] of this.queues) {
+            closeTasks.push(queue.close().then(() => {
+                logger.info("[queue:bullmq] Queue closed", { queue: name });
+            }));
+        }
+        await Promise.allSettled(closeTasks);
+        await this.connection.quit();
+        this.workers.clear();
+        this.queues.clear();
+        this.handlers.clear();
+        logger.info("[queue:bullmq] Provider closed");
+    }
+}

package/dist/providers/memory.d.ts

@@ -0,0 +1,23 @@
+import type { DeadLetterJob, JobHandler, JobLifecycleActionResult, JobLifecycleEvent, JobPayload, JobResult, JobStatusInfo, QueueProvider } from "../types";
+export declare class MemoryProvider implements QueueProvider {
+    readonly name: "memory";
+    private handlers;
+    private jobs;
+    private deadLetters;
+    private timers;
+    constructor();
+    enqueue(job: JobPayload): Promise<JobResult>;
+    enqueueBatch(jobs: JobPayload[]): Promise<JobResult[]>;
+    registerHandler<T extends Record<string, unknown>>(queue: string, type: string, handler: JobHandler<T>): void;
+    getJobStatus(jobId: string, _queue?: string): Promise<JobStatusInfo | undefined>;
+    getDeadLetteredJobs(queue?: string): Promise<DeadLetterJob[]>;
+    getJobLogs(jobId: string, _queue: string): Promise<JobLifecycleEvent[]>;
+    cancelJob(jobId: string, queue: string, reason?: string): Promise<JobLifecycleActionResult>;
+    retryJob(jobId: string, queue: string, reason?: string): Promise<JobLifecycleActionResult>;
+    private processJob;
+    private deadLetter;
+    close(): Promise<void>;
+    private trackTimer;
+    private appendLog;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/providers/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/providers/memory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,UAAU,EAEV,wBAAwB,EACxB,iBAAiB,EACjB,UAAU,EACV,SAAS,EACT,aAAa,EACb,aAAa,EACd,MAAM,UAAU,CAAC;AA4BlB,qBAAa,cAAe,YAAW,aAAa;IAClD,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAElC,OAAO,CAAC,QAAQ,CAAsC;IACtD,OAAO,CAAC,IAAI,CAAqC;IACjD,OAAO,CAAC,WAAW,CAAyC;IAC5D,OAAO,CAAC,MAAM,CAAuC;;IAQ/C,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC;IA6B5C,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAU5D,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/C,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GACrB,IAAI;IAQD,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC;IAoBhF,mBAAmB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAK7D,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;IAIvE,SAAS,CACb,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,SAAa,GAClB,OAAO,CAAC,wBAAwB,CAAC;IAyB9B,QAAQ,CACZ,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,SAAiB,GACtB,OAAO,CAAC,wBAAwB,CAAC;YA6BtB,UAAU;IAyDxB,OAAO,CAAC,UAAU;IA0BZ,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAW5B,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,SAAS;CAiBlB"}

package/dist/providers/memory.js

@@ -0,0 +1,220 @@
+import { logger } from "@nebutra/logger";
+export class MemoryProvider {
+    name = "memory";
+    handlers = new Map();
+    jobs = new Map();
+    deadLetters = new Map();
+    timers = [];
+    constructor() {
+        logger.info("[queue:memory] Provider initialised (dev/test only)");
+    }
+    // ── Enqueue ─────────────────────────────────────────────────────────────
+    async enqueue(job) {
+        const delaySec = job.options?.delaySec ?? 0;
+        this.jobs.set(job.id, {
+            payload: job,
+            status: delaySec > 0 ? "delayed" : "pending",
+            attempts: 0,
+            logs: [],
+        });
+        this.appendLog(job, "enqueued", {
+            ...(delaySec > 0 ? { metadata: { delaySec } } : {}),
+        });
+        if (delaySec > 0) {
+            const timer = setTimeout(() => this.processJob(job), delaySec * 1000);
+            this.trackTimer(job.id, timer);
+        }
+        else {
+            // Process on next tick to simulate async behaviour
+            const timer = setTimeout(() => this.processJob(job), 0);
+            this.trackTimer(job.id, timer);
+        }
+        return {
+            jobId: job.id,
+            accepted: true,
+            provider: "memory",
+        };
+    }
+    async enqueueBatch(jobs) {
+        const results = [];
+        for (const job of jobs) {
+            results.push(await this.enqueue(job));
+        }
+        return results;
+    }
+    // ── Handler Registration ────────────────────────────────────────────────
+    registerHandler(queue, type, handler) {
+        const key = `${queue}:${type}`;
+        this.handlers.set(key, handler);
+        logger.info("[queue:memory] Handler registered", { key });
+    }
+    // ── Job Status ──────────────────────────────────────────────────────────
+    async getJobStatus(jobId, _queue) {
+        const stored = this.jobs.get(jobId);
+        if (!stored)
+            return undefined;
+        return {
+            id: jobId,
+            queue: stored.payload.queue,
+            status: stored.status,
+            attempts: stored.attempts,
+            maxRetries: stored.payload.options?.maxRetries ?? 3,
+            ...(stored.failedReason !== undefined ? { failedReason: stored.failedReason } : {}),
+            ...(stored.canceledReason !== undefined ? { canceledReason: stored.canceledReason } : {}),
+            createdAt: stored.payload.createdAt,
+            ...(stored.processedAt !== undefined ? { processedAt: stored.processedAt } : {}),
+            ...(stored.completedAt !== undefined ? { completedAt: stored.completedAt } : {}),
+            ...(stored.deadLetteredAt !== undefined ? { deadLetteredAt: stored.deadLetteredAt } : {}),
+            ...(stored.canceledAt !== undefined ? { canceledAt: stored.canceledAt } : {}),
+        };
+    }
+    async getDeadLetteredJobs(queue) {
+        const jobs = [...this.deadLetters.values()];
+        return queue === undefined ? jobs : jobs.filter((job) => job.queue === queue);
+    }
+    async getJobLogs(jobId, _queue) {
+        return [...(this.jobs.get(jobId)?.logs ?? [])];
+    }
+    async cancelJob(jobId, queue, reason = "canceled") {
+        const stored = this.jobs.get(jobId);
+        if (!stored || stored.payload.queue !== queue) {
+            return { jobId, queue, accepted: false, action: "cancel", reason: "Job not found" };
+        }
+        if (!["pending", "delayed"].includes(stored.status)) {
+            return { jobId, queue, accepted: false, action: "cancel", reason: `Job is ${stored.status}` };
+        }
+        if (stored.timer) {
+            clearTimeout(stored.timer);
+            this.timers = this.timers.filter((timer) => timer !== stored.timer);
+            stored.timer = undefined;
+        }
+        const canceledAt = new Date().toISOString();
+        stored.status = "canceled";
+        stored.canceledReason = reason;
+        stored.canceledAt = canceledAt;
+        this.appendLog(stored.payload, "canceled", { reason });
+        return { jobId, queue, accepted: true, action: "cancel", reason };
+    }
+    async retryJob(jobId, queue, reason = "manual-retry") {
+        const stored = this.jobs.get(jobId);
+        if (!stored || stored.payload.queue !== queue) {
+            return { jobId, queue, accepted: false, action: "retry", reason: "Job not found" };
+        }
+        if (!["failed", "dead-lettered", "canceled"].includes(stored.status)) {
+            return { jobId, queue, accepted: false, action: "retry", reason: `Job is ${stored.status}` };
+        }
+        stored.status = "pending";
+        stored.attempts = 0;
+        stored.failedReason = undefined;
+        stored.canceledReason = undefined;
+        stored.processedAt = undefined;
+        stored.completedAt = undefined;
+        stored.deadLetteredAt = undefined;
+        stored.canceledAt = undefined;
+        this.deadLetters.delete(jobId);
+        this.appendLog(stored.payload, "retried", { reason });
+        const timer = setTimeout(() => this.processJob(stored.payload), 0);
+        this.trackTimer(jobId, timer);
+        return { jobId, queue, accepted: true, action: "retry", reason };
+    }
+    // ── Internal Processing ─────────────────────────────────────────────────
+    async processJob(job) {
+        const key = `${job.queue}:${job.type}`;
+        const handler = this.handlers.get(key);
+        const stored = this.jobs.get(job.id);
+        if (!stored)
+            return;
+        stored.timer = undefined;
+        if (stored.status === "canceled") {
+            logger.info("[queue:memory] Skipping canceled job", { jobId: job.id, key });
+            return;
+        }
+        if (!handler) {
+            logger.warn("[queue:memory] No handler for job type", { key, jobId: job.id });
+            stored.status = "failed";
+            stored.failedReason = `No handler registered for ${key}`;
+            this.appendLog(job, "failed", { reason: stored.failedReason });
+            return;
+        }
+        const maxRetries = job.options?.maxRetries ?? 3;
+        stored.status = "active";
+        stored.processedAt = new Date().toISOString();
+        this.appendLog(job, "started");
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            stored.attempts = attempt;
+            try {
+                await handler(job);
+                stored.status = "completed";
+                stored.completedAt = new Date().toISOString();
+                this.appendLog(job, "completed", { attempt });
+                logger.info("[queue:memory] Job completed", { jobId: job.id, key });
+                return;
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                this.appendLog(job, "attempt-failed", { attempt, reason: msg });
+                logger.warn("[queue:memory] Job attempt failed", {
+                    jobId: job.id,
+                    attempt,
+                    maxRetries,
+                    error: msg,
+                });
+                if (attempt === maxRetries) {
+                    this.deadLetter(job, stored, msg, maxRetries);
+                    logger.error("[queue:memory] Job exhausted retries", {
+                        jobId: job.id,
+                        key,
+                    });
+                }
+            }
+        }
+    }
+    deadLetter(job, stored, failedReason, maxRetries) {
+        const failedAt = new Date().toISOString();
+        stored.status = "dead-lettered";
+        stored.failedReason = failedReason;
+        stored.deadLetteredAt = failedAt;
+        this.appendLog(job, "dead-lettered", { reason: failedReason });
+        this.deadLetters.set(job.id, {
+            id: job.id,
+            queue: job.queue,
+            type: job.type,
+            originalJob: job,
+            attempts: stored.attempts,
+            maxRetries,
+            failedReason,
+            provider: "memory",
+            failedAt,
+        });
+    }
+    // ── Lifecycle ───────────────────────────────────────────────────────────
+    async close() {
+        for (const timer of this.timers) {
+            clearTimeout(timer);
+        }
+        this.timers = [];
+        this.handlers.clear();
+        this.jobs.clear();
+        this.deadLetters.clear();
+        logger.info("[queue:memory] Provider closed");
+    }
+    trackTimer(jobId, timer) {
+        this.timers.push(timer);
+        const stored = this.jobs.get(jobId);
+        if (stored)
+            stored.timer = timer;
+    }
+    appendLog(job, action, details = {}) {
+        const stored = this.jobs.get(job.id);
+        if (!stored)
+            return;
+        stored.logs.push({
+            id: `log_${crypto.randomUUID()}`,
+            jobId: job.id,
+            queue: job.queue,
+            action,
+            at: new Date().toISOString(),
+            ...details,
+        });
+    }
+}

package/dist/providers/qstash.d.ts

@@ -0,0 +1,26 @@
+import type { DeadLetterJob, JobHandler, JobPayload, JobResult, QStashProviderConfig, QueueDeadLetterRecord, QueueProvider } from "../types";
+/**
+ * Get a registered handler by its composite key (`queue:type`).
+ * Used by the QStash webhook verification middleware.
+ */
+export declare function getQStashHandler(queue: string, type: string): JobHandler | undefined;
+/**
+ * Get ALL registered handlers (for introspection / health checks).
+ */
+export declare function getQStashHandlerKeys(): string[];
+export declare function toQStashDeadLetterJob(record: QueueDeadLetterRecord): DeadLetterJob | undefined;
+export declare class QStashProvider implements QueueProvider {
+    readonly name: "qstash";
+    private client;
+    private callbackBaseUrl;
+    private token;
+    private dlqEndpoint;
+    private dlqFetcher;
+    constructor(config: Omit<QStashProviderConfig, "provider">);
+    enqueue(job: JobPayload): Promise<JobResult>;
+    enqueueBatch(jobs: JobPayload[]): Promise<JobResult[]>;
+    registerHandler<T extends Record<string, unknown>>(queue: string, type: string, handler: JobHandler<T>): void;
+    getDeadLetteredJobs(queue?: string): Promise<DeadLetterJob[]>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=qstash.d.ts.map

package/dist/providers/qstash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qstash.d.ts","sourceRoot":"","sources":["../../src/providers/qstash.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,aAAa,EACb,UAAU,EACV,UAAU,EACV,SAAS,EACT,oBAAoB,EAEpB,qBAAqB,EACrB,aAAa,EACd,MAAM,UAAU,CAAC;AAoBlB;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAEpF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C;AAiDD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,aAAa,GAAG,SAAS,CAmB9F;AAED,qBAAa,cAAe,YAAW,aAAa;IAClD,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAElC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,UAAU,CAAqC;gBAE3C,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,UAAU,CAAC;IAqBpD,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC;IA2C5C,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IA4C5D,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/C,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GACrB,IAAI;IAMD,mBAAmB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IA2B7D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAI7B"}