duron 0.2.1 → 0.3.0-beta.0

package/dist/step-manager.js

@@ -1,7 +1,7 @@
 import fastq from 'fastq';
 import { StepOptionsSchema, } from './action.js';
 import { STEP_STATUS_CANCELLED, STEP_STATUS_COMPLETED, STEP_STATUS_FAILED } from './constants.js';
-import { ActionCancelError, isCancelError, isNonRetriableError, NonRetriableError, StepAlreadyExecutedError, StepTimeoutError, serializeError, } from './errors.js';
+import { ActionCancelError, isCancelError, isNonRetriableError, NonRetriableError, StepAlreadyExecutedError, StepTimeoutError, serializeError, UnhandledChildStepsError, } from './errors.js';
 import pRetry from './utils/p-retry.js';
 import waitForAbort from './utils/wait-for-abort.js';
 export class StepStore {
@@ -9,13 +9,15 @@ export class StepStore {
     constructor(adapter) {
         this.#adapter = adapter;
     }
-    async getOrCreate(jobId, name, timeoutMs, retriesLimit) {
+    async getOrCreate(jobId, name, timeoutMs, retriesLimit, parentStepId = null, parallel = false) {
         try {
             return await this.#adapter.createOrRecoverJobStep({
                 jobId,
                 name,
                 timeoutMs,
                 retriesLimit,
+                parentStepId,
+                parallel,
             });
         }
         catch (error) {
@@ -42,24 +44,48 @@ export class StepManager {
     #jobId;
     #actionName;
     #stepStore;
+    #telemetry;
     #queue;
     #logger;
     #historySteps = new Set();
+    #stepSpans = new Map();
+    #jobSpan = null;
     constructor(options) {
         this.#jobId = options.jobId;
         this.#actionName = options.actionName;
         this.#logger = options.logger;
+        this.#telemetry = options.telemetry;
         this.#stepStore = new StepStore(options.adapter);
         this.#queue = fastq.promise(async (task) => {
             if (this.#historySteps.has(task.name)) {
                 throw new StepAlreadyExecutedError(task.name, this.#jobId, this.#actionName);
             }
             this.#historySteps.add(task.name);
-            return this.#executeStep(task.name, task.cb, task.options, task.abortSignal);
+            return this.#executeStep(task.name, task.cb, task.options, task.abortSignal, task.parentStepId, task.parallel);
         }, options.concurrencyLimit);
     }
-    createActionContext(job, action, variables, abortSignal, logger) {
-        return new ActionContext(this, job, action, variables, abortSignal, logger);
+    setJobSpan(span) {
+        this.#jobSpan = span;
+    }
+    createActionContext(job, action, variables, abortSignal, logger, observeContext) {
+        return new ActionContext(this, job, action, variables, abortSignal, logger, observeContext);
+    }
+    createStepObserveContext(stepId) {
+        const stepSpan = this.#stepSpans.get(stepId);
+        if (stepSpan) {
+            return this.#telemetry.createObserveContext(this.#jobId, stepId, stepSpan);
+        }
+        if (this.#jobSpan) {
+            return this.#telemetry.createObserveContext(this.#jobId, stepId, this.#jobSpan);
+        }
+        return {
+            recordMetric: () => {
+            },
+            addSpanAttribute: () => {
+            },
+            addSpanEvent: () => {
+            },
+        };
     }
     async push(task) {
         return this.#queue.push(task);
@@ -67,7 +93,7 @@ export class StepManager {
     async drain() {
         await this.#queue.drain();
     }
-    async #executeStep(name, cb, options, abortSignal) {
+    async #executeStep(name, cb, options, abortSignal, parentStepId, parallel) {
         const expire = options.expire;
         const retryOptions = options.retry;
         let step = null;
@@ -76,16 +102,25 @@ export class StepManager {
                 if (abortSignal.aborted) {
                     throw new ActionCancelError(this.#actionName, this.#jobId, { cause: 'step cancelled before create step' });
                 }
-                const newStep = await this.#stepStore.getOrCreate(this.#jobId, name, expire, retryOptions.limit);
+                const newStep = await this.#stepStore.getOrCreate(this.#jobId, name, expire, retryOptions.limit, parentStepId, parallel);
                 if (!newStep) {
                     throw new NonRetriableError(`Failed to create step "${name}" for job "${this.#jobId}" action "${this.#actionName}"`, { cause: 'step not created' });
                 }
                 step = newStep;
+                const parentSpan = parentStepId ? this.#stepSpans.get(parentStepId) : this.#jobSpan;
+                const stepSpan = await this.#telemetry.startStepSpan({
+                    jobId: this.#jobId,
+                    stepId: step.id,
+                    stepName: name,
+                    parentSpan: parentSpan ?? undefined,
+                    parentStepId,
+                });
+                this.#stepSpans.set(step.id, stepSpan);
                 if (abortSignal.aborted) {
                     throw new ActionCancelError(this.#actionName, this.#jobId, { cause: 'step cancelled after create step' });
                 }
                 if (step.status === STEP_STATUS_COMPLETED) {
-                    this.#logger.debug({ jobId: this.#jobId, actionName: this.#actionName, stepName: name, stepId: step.id }, '[StepManager] Step recovered (already completed)');
+                    this.#logger.debug({ jobId: this.#jobId, actionName: this.#actionName, stepName: name, stepId: step.id, parentStepId }, '[StepManager] Step recovered (already completed)');
                     return step.output;
                 }
                 else if (step.status === STEP_STATUS_FAILED) {
@@ -96,7 +131,7 @@ export class StepManager {
                 else if (step.status === STEP_STATUS_CANCELLED) {
                     throw new NonRetriableError(`Cannot recover a cancelled step "${name}" for job "${this.#jobId}" action "${this.#actionName}"`, { cause: step.error });
                 }
-                this.#logger.debug({ jobId: this.#jobId, actionName: this.#actionName, stepName: name, stepId: step.id }, '[StepManager] Step started executing');
+                this.#logger.debug({ jobId: this.#jobId, actionName: this.#actionName, stepName: name, stepId: step.id, parentStepId }, '[StepManager] Step started executing');
             }
             const stepAbortController = new AbortController();
             const timeoutId = setTimeout(() => {
@@ -104,13 +139,54 @@ export class StepManager {
                 stepAbortController.abort(timeoutError);
             }, expire);
             timeoutId?.unref?.();
-            const signal = AbortSignal.any([abortSignal, stepAbortController.signal]);
+            const stepSignal = AbortSignal.any([abortSignal, stepAbortController.signal]);
+            const childSteps = [];
+            const childAbortController = new AbortController();
+            const childSignal = AbortSignal.any([stepSignal, childAbortController.signal]);
+            const stepObserveContext = this.createStepObserveContext(step.id);
+            const stepContext = {
+                signal: stepSignal,
+                stepId: step.id,
+                parentStepId,
+                observe: stepObserveContext,
+                step: (childName, childCb, childOptions = {}) => {
+                    const { parallel: _parentParallel, ...inheritableOptions } = options;
+                    const parsedChildOptions = StepOptionsSchema.parse({
+                        ...inheritableOptions,
+                        ...childOptions,
+                    });
+                    const childPromise = this.push({
+                        name: childName,
+                        cb: childCb,
+                        options: parsedChildOptions,
+                        abortSignal: childSignal,
+                        parentStepId: step.id,
+                        parallel: parsedChildOptions.parallel,
+                    });
+                    const trackedChild = {
+                        promise: childPromise,
+                        settled: false,
+                    };
+                    childSteps.push(trackedChild);
+                    childPromise
+                        .then(() => {
+                        trackedChild.settled = true;
+                    })
+                        .catch(() => {
+                        trackedChild.settled = true;
+                    });
+                    return childPromise;
+                },
+            };
             try {
-                const abortPromise = waitForAbort(signal);
-                const callbackPromise = cb({ signal });
+                const abortPromise = waitForAbort(stepSignal);
+                const callbackPromise = cb(stepContext);
                 let result = null;
+                let aborted = false;
                 await Promise.race([
-                    abortPromise.promise,
+                    abortPromise.promise.then(() => {
+                        aborted = true;
+                    }),
                     callbackPromise
                         .then((res) => {
                         if (res !== undefined && res !== null) {
@@ -121,10 +197,35 @@ export class StepManager {
                         abortPromise.release();
                     }),
                 ]);
+                if (aborted) {
+                    if (childSteps.length > 0) {
+                        await Promise.allSettled(childSteps.map((c) => c.promise));
+                    }
+                    throw stepSignal.reason;
+                }
+                const unsettledChildren = childSteps.filter((c) => !c.settled);
+                if (unsettledChildren.length > 0) {
+                    this.#logger.warn({
+                        jobId: this.#jobId,
+                        actionName: this.#actionName,
+                        stepName: name,
+                        stepId: step.id,
+                        pendingCount: unsettledChildren.length,
+                    }, '[StepManager] Parent step completed with unhandled child steps - aborting children');
+                    const unhandledError = new UnhandledChildStepsError(name, unsettledChildren.length);
+                    childAbortController.abort(unhandledError);
+                    await Promise.allSettled(unsettledChildren.map((c) => c.promise));
+                    throw unhandledError;
+                }
                 const completed = await this.#stepStore.updateStatus(step.id, 'completed', result);
                 if (!completed) {
                     throw new Error(`Failed to complete step "${name}" for job "${this.#jobId}" action "${this.#actionName}"`);
                 }
+                const stepSpan = this.#stepSpans.get(step.id);
+                if (stepSpan) {
+                    await this.#telemetry.endStepSpan(stepSpan, { status: 'ok' });
+                    this.#stepSpans.delete(step.id);
+                }
                 this.#logger.debug({ jobId: this.#jobId, actionName: this.#actionName, stepName: name, stepId: step.id }, '[StepManager] Step finished executing');
                 return result;
             }
@@ -155,6 +256,16 @@ export class StepManager {
             },
         }).catch(async (error) => {
             if (step) {
+                const stepSpan = this.#stepSpans.get(step.id);
+                if (stepSpan) {
+                    if (isCancelError(error)) {
+                        await this.#telemetry.endStepSpan(stepSpan, { status: 'cancelled' });
+                    }
+                    else {
+                        await this.#telemetry.endStepSpan(stepSpan, { status: 'error', error });
+                    }
+                    this.#stepSpans.delete(step.id);
+                }
                 if (isCancelError(error)) {
                     await this.#stepStore.updateStatus(step.id, 'cancelled');
                 }
@@ -175,7 +286,8 @@ class ActionContext {
     #jobId;
     #groupKey = '@default';
     #action;
-    constructor(stepManager, job, action, variables, abortSignal, logger) {
+    #observeContext;
+    constructor(stepManager, job, action, variables, abortSignal, logger, observeContext) {
         this.#stepManager = stepManager;
         this.#variables = variables;
         this.#abortSignal = abortSignal;
@@ -183,6 +295,7 @@ class ActionContext {
         this.#action = action;
         this.#jobId = job.id;
         this.#groupKey = job.groupKey ?? '@default';
+        this.#observeContext = observeContext;
         if (action.input) {
             this.#input = action.input.parse(job.input, {
                 error: () => 'Error parsing action input',
@@ -207,11 +320,21 @@ class ActionContext {
     get logger() {
         return this.#logger;
     }
+    get observe() {
+        return this.#observeContext;
+    }
     async step(name, cb, options = {}) {
         const parsedOptions = StepOptionsSchema.parse({
             ...this.#action.steps,
             ...options,
         });
-        return this.#stepManager.push({ name, cb, options: parsedOptions, abortSignal: this.#abortSignal });
+        return this.#stepManager.push({
+            name,
+            cb,
+            options: parsedOptions,
+            abortSignal: this.#abortSignal,
+            parentStepId: null,
+            parallel: parsedOptions.parallel,
+        });
     }
 }

package/dist/telemetry/adapter.d.ts

@@ -0,0 +1,85 @@
+import type { Logger } from 'pino';
+import type { Adapter } from '../adapters/adapter.js';
+export interface TelemetryClient {
+    database: Adapter;
+}
+export interface Span {
+    id: string;
+    jobId: string;
+    stepId: string | null;
+    parentSpanId: string | null;
+}
+export interface StartJobSpanOptions {
+    jobId: string;
+    actionName: string;
+    groupKey: string;
+    input?: any;
+}
+export interface StartStepSpanOptions {
+    jobId: string;
+    stepId: string;
+    stepName: string;
+    parentSpan?: Span;
+    parentStepId: string | null;
+}
+export interface EndSpanOptions {
+    status: 'ok' | 'error' | 'cancelled';
+    error?: any;
+}
+export interface StartDatabaseSpanOptions {
+    operation: string;
+    query?: string;
+}
+export interface RecordMetricOptions {
+    jobId: string;
+    stepId?: string;
+    name: string;
+    value: number;
+    attributes?: Record<string, any>;
+}
+export interface AddSpanEventOptions {
+    span: Span;
+    name: string;
+    attributes?: Record<string, any>;
+}
+export interface AddSpanAttributeOptions {
+    span: Span;
+    key: string;
+    value: string | number | boolean;
+}
+export interface ObserveContext {
+    recordMetric(name: string, value: number, attributes?: Record<string, any>): void;
+    addSpanAttribute(key: string, value: string | number | boolean): void;
+    addSpanEvent(name: string, attributes?: Record<string, any>): void;
+}
+export declare abstract class TelemetryAdapter {
+    #private;
+    start(): Promise<boolean>;
+    stop(): Promise<boolean>;
+    setLogger(logger: Logger): void;
+    get logger(): Logger | null;
+    setClient(client: TelemetryClient): void;
+    protected get client(): TelemetryClient | null;
+    startJobSpan(options: StartJobSpanOptions): Promise<Span>;
+    endJobSpan(span: Span, options: EndSpanOptions): Promise<void>;
+    startStepSpan(options: StartStepSpanOptions): Promise<Span>;
+    endStepSpan(span: Span, options: EndSpanOptions): Promise<void>;
+    startDatabaseSpan(options: StartDatabaseSpanOptions): Promise<Span | null>;
+    endDatabaseSpan(span: Span | null, options: EndSpanOptions): Promise<void>;
+    recordMetric(options: RecordMetricOptions): Promise<void>;
+    addSpanEvent(options: AddSpanEventOptions): Promise<void>;
+    addSpanAttribute(options: AddSpanAttributeOptions): Promise<void>;
+    createObserveContext(jobId: string, stepId: string | null, span: Span): ObserveContext;
+    protected abstract _start(): Promise<void>;
+    protected abstract _stop(): Promise<void>;
+    protected abstract _startJobSpan(options: StartJobSpanOptions): Promise<Span>;
+    protected abstract _endJobSpan(span: Span, options: EndSpanOptions): Promise<void>;
+    protected abstract _startStepSpan(options: StartStepSpanOptions): Promise<Span>;
+    protected abstract _endStepSpan(span: Span, options: EndSpanOptions): Promise<void>;
+    protected abstract _startDatabaseSpan(options: StartDatabaseSpanOptions): Promise<Span | null>;
+    protected abstract _endDatabaseSpan(span: Span, options: EndSpanOptions): Promise<void>;
+    protected abstract _recordMetric(options: RecordMetricOptions): Promise<void>;
+    protected abstract _addSpanEvent(options: AddSpanEventOptions): Promise<void>;
+    protected abstract _addSpanAttribute(options: AddSpanAttributeOptions): Promise<void>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/telemetry/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/telemetry/adapter.ts"],"names":[],"mappings":"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"}

package/dist/telemetry/adapter.js

@@ -0,0 +1,128 @@
+export class TelemetryAdapter {
+    #logger = null;
+    #client = null;
+    #started = false;
+    #stopped = false;
+    #starting = null;
+    #stopping = null;
+    async start() {
+        try {
+            if (this.#stopping || this.#stopped) {
+                return false;
+            }
+            if (this.#started) {
+                return true;
+            }
+            if (this.#starting) {
+                return this.#starting;
+            }
+            this.#starting = (async () => {
+                await this._start();
+                this.#started = true;
+                this.#starting = null;
+                return true;
+            })();
+            return this.#starting;
+        }
+        catch (error) {
+            this.#logger?.error(error, 'Error in TelemetryAdapter.start()');
+            throw error;
+        }
+    }
+    async stop() {
+        try {
+            if (this.#stopped) {
+                return true;
+            }
+            if (this.#stopping) {
+                return this.#stopping;
+            }
+            this.#stopping = (async () => {
+                await this._stop();
+                this.#stopped = true;
+                this.#stopping = null;
+                return true;
+            })();
+            return this.#stopping;
+        }
+        catch (error) {
+            this.#logger?.error(error, 'Error in TelemetryAdapter.stop()');
+            throw error;
+        }
+    }
+    setLogger(logger) {
+        this.#logger = logger;
+    }
+    get logger() {
+        return this.#logger;
+    }
+    setClient(client) {
+        this.#client = client;
+    }
+    get client() {
+        return this.#client;
+    }
+    async startJobSpan(options) {
+        await this.start();
+        return this._startJobSpan(options);
+    }
+    async endJobSpan(span, options) {
+        await this.start();
+        return this._endJobSpan(span, options);
+    }
+    async startStepSpan(options) {
+        await this.start();
+        return this._startStepSpan(options);
+    }
+    async endStepSpan(span, options) {
+        await this.start();
+        return this._endStepSpan(span, options);
+    }
+    async startDatabaseSpan(options) {
+        await this.start();
+        return this._startDatabaseSpan(options);
+    }
+    async endDatabaseSpan(span, options) {
+        if (!span)
+            return;
+        await this.start();
+        return this._endDatabaseSpan(span, options);
+    }
+    async recordMetric(options) {
+        await this.start();
+        return this._recordMetric(options);
+    }
+    async addSpanEvent(options) {
+        await this.start();
+        return this._addSpanEvent(options);
+    }
+    async addSpanAttribute(options) {
+        await this.start();
+        return this._addSpanAttribute(options);
+    }
+    createObserveContext(jobId, stepId, span) {
+        return {
+            recordMetric: (name, value, attributes) => {
+                this.recordMetric({
+                    jobId,
+                    stepId: stepId ?? undefined,
+                    name,
+                    value,
+                    attributes,
+                }).catch((err) => {
+                    this.#logger?.error(err, 'Error recording metric');
+                });
+            },
+            addSpanAttribute: (key, value) => {
+                this.addSpanAttribute({ span, key, value }).catch((err) => {
+                    this.#logger?.error(err, 'Error adding span attribute');
+                });
+            },
+            addSpanEvent: (name, attributes) => {
+                this.addSpanEvent({ span, name, attributes }).catch((err) => {
+                    this.#logger?.error(err, 'Error adding span event');
+                });
+            },
+        };
+    }
+}

package/dist/telemetry/index.d.ts

@@ -0,0 +1,5 @@
+export { type AddSpanAttributeOptions, type AddSpanEventOptions, type EndSpanOptions, type ObserveContext, type RecordMetricOptions, type Span, type StartDatabaseSpanOptions, type StartJobSpanOptions, type StartStepSpanOptions, TelemetryAdapter, } from './adapter.js';
+export { LocalTelemetryAdapter, type LocalTelemetryAdapterOptions, localTelemetryAdapter } from './local.js';
+export { NoopTelemetryAdapter, noopTelemetryAdapter } from './noop.js';
+export { OpenTelemetryAdapter, type OpenTelemetryAdapterOptions, openTelemetryAdapter } from './opentelemetry.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/telemetry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/telemetry/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,IAAI,EACT,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,gBAAgB,GACjB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,qBAAqB,EAAE,KAAK,4BAA4B,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAC5G,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AACtE,OAAO,EAAE,oBAAoB,EAAE,KAAK,2BAA2B,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA"}

package/dist/telemetry/index.js

@@ -0,0 +1,4 @@
+export { TelemetryAdapter, } from './adapter.js';
+export { LocalTelemetryAdapter, localTelemetryAdapter } from './local.js';
+export { NoopTelemetryAdapter, noopTelemetryAdapter } from './noop.js';
+export { OpenTelemetryAdapter, openTelemetryAdapter } from './opentelemetry.js';

package/dist/telemetry/local.d.ts

@@ -0,0 +1,21 @@
+import { type AddSpanAttributeOptions, type AddSpanEventOptions, type EndSpanOptions, type RecordMetricOptions, type Span, type StartDatabaseSpanOptions, type StartJobSpanOptions, type StartStepSpanOptions, TelemetryAdapter } from './adapter.js';
+export interface LocalTelemetryAdapterOptions {
+    flushDelayMs?: number;
+}
+export declare class LocalTelemetryAdapter extends TelemetryAdapter {
+    #private;
+    constructor(options?: LocalTelemetryAdapterOptions);
+    protected _start(): Promise<void>;
+    protected _stop(): Promise<void>;
+    protected _startJobSpan(options: StartJobSpanOptions): Promise<Span>;
+    protected _endJobSpan(span: Span, options: EndSpanOptions): Promise<void>;
+    protected _startStepSpan(options: StartStepSpanOptions): Promise<Span>;
+    protected _endStepSpan(span: Span, options: EndSpanOptions): Promise<void>;
+    protected _startDatabaseSpan(_options: StartDatabaseSpanOptions): Promise<Span | null>;
+    protected _endDatabaseSpan(_span: Span, _options: EndSpanOptions): Promise<void>;
+    protected _recordMetric(options: RecordMetricOptions): Promise<void>;
+    protected _addSpanEvent(options: AddSpanEventOptions): Promise<void>;
+    protected _addSpanAttribute(options: AddSpanAttributeOptions): Promise<void>;
+}
+export declare const localTelemetryAdapter: (options?: LocalTelemetryAdapterOptions) => LocalTelemetryAdapter;
+//# sourceMappingURL=local.d.ts.map

package/dist/telemetry/local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.d.ts","sourceRoot":"","sources":["../../src/telemetry/local.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,IAAI,EACT,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,gBAAgB,EACjB,MAAM,cAAc,CAAA;AAMrB,MAAM,WAAW,4BAA4B;IAM3C,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AA4BD,qBAAa,qBAAsB,SAAQ,gBAAgB;;gBAO7C,OAAO,CAAC,EAAE,4BAA4B;cAwFlC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;cAIvB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;cAUtB,aAAa,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;cAyB1D,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;cAoB/D,cAAc,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;cA2B5D,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;cAqBhE,kBAAkB,CAAC,QAAQ,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;cAK5E,gBAAgB,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;cAQtE,aAAa,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;cAW1D,aAAa,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;cAc1D,iBAAiB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;CAcnF;AA6BD,eAAO,MAAM,qBAAqB,GAAI,UAAU,4BAA4B,0BAAuC,CAAA"}