@mastra/observability 0.0.0-safe-stringify-telemetry-20251205024938 → 0.0.0-salesman-20260127182805

package/dist/exporters/base.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Base Exporter for Observability
+ *
+ * Provides common functionality shared by all observability exporters:
+ * - Logger initialization with proper Mastra logger support
+ * - Disabled state management
+ * - Graceful shutdown lifecycle
+ */
+import { LogLevel } from '@mastra/core/logger';
+import type { IMastraLogger } from '@mastra/core/logger';
+import type { TracingEvent, ObservabilityExporter, InitExporterOptions, CustomSpanFormatter } from '@mastra/core/observability';
+/**
+ * Base configuration that all exporters should support
+ */
+export interface BaseExporterConfig {
+    /** Optional Mastra logger instance */
+    logger?: IMastraLogger;
+    /** Log level for the exporter (defaults to INFO) - accepts both enum and string */
+    logLevel?: LogLevel | 'debug' | 'info' | 'warn' | 'error';
+    /**
+     * Custom span formatter function to transform exported spans before they are
+     * processed by the exporter. This allows customization of how spans appear
+     * in vendor-specific observability platforms.
+     *
+     * Use cases:
+     * - Extract plain text from structured AI SDK messages for better readability
+     * - Transform input/output format for specific vendor requirements
+     * - Add or remove fields based on the target platform
+     *
+     * @example
+     * ```typescript
+     * const exporter = new BraintrustExporter({
+     *   customSpanFormatter: (span) => {
+     *     // Extract plain text user message for AGENT_RUN spans
+     *     if (span.type === SpanType.AGENT_RUN && Array.isArray(span.input)) {
+     *       const userMsg = span.input.find(m => m.role === 'user');
+     *       return { ...span, input: userMsg?.content ?? span.input };
+     *     }
+     *     return span;
+     *   },
+     * });
+     * ```
+     */
+    customSpanFormatter?: CustomSpanFormatter;
+}
+/**
+ * Abstract base class for observability exporters
+ *
+ * Handles common concerns:
+ * - Logger setup with proper Mastra logger
+ * - Disabled state management
+ * - Basic lifecycle methods
+ *
+ * @example
+ * ```typescript
+ * class MyExporter extends BaseExporter {
+ *   name = 'my-exporter';
+ *
+ *   constructor(config: MyExporterConfig) {
+ *     super(config);
+ *
+ *     if (!config.apiKey) {
+ *       this.setDisabled('Missing API key');
+ *       return;
+ *     }
+ *
+ *     // Initialize exporter-specific logic
+ *   }
+ *
+ *   async _exportEvent(event: TracingEvent): Promise<void> {
+ *     // Export logic
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class BaseExporter implements ObservabilityExporter {
+    #private;
+    /** Exporter name - must be implemented by subclasses */
+    abstract name: string;
+    /** Mastra logger instance */
+    protected logger: IMastraLogger;
+    /** Base configuration (accessible by subclasses) */
+    protected readonly baseConfig: BaseExporterConfig;
+    /** Public getter for disabled state */
+    get isDisabled(): boolean;
+    /**
+     * Initialize the base exporter with logger
+     */
+    constructor(config?: BaseExporterConfig);
+    /**
+     * Set the logger for the exporter (called by Mastra/ObservabilityInstance during initialization)
+     */
+    __setLogger(logger: IMastraLogger): void;
+    /**
+     * Convert string log level to LogLevel enum
+     */
+    private resolveLogLevel;
+    /**
+     * Mark the exporter as disabled and log a message
+     *
+     * @param reason - Reason why the exporter is disabled
+     */
+    protected setDisabled(reason: string): void;
+    /**
+     * Apply the customSpanFormatter if configured.
+     * This is called automatically by exportTracingEvent before _exportTracingEvent.
+     *
+     * Supports both synchronous and asynchronous formatters. If the formatter
+     * returns a Promise, it will be awaited.
+     *
+     * @param event - The incoming tracing event
+     * @returns The (possibly modified) event to process
+     */
+    protected applySpanFormatter(event: TracingEvent): Promise<TracingEvent>;
+    /**
+     * Export a tracing event
+     *
+     * This method checks if the exporter is disabled, applies the customSpanFormatter,
+     * then calls _exportTracingEvent.
+     * Subclasses should implement _exportTracingEvent instead of overriding this method.
+     */
+    exportTracingEvent(event: TracingEvent): Promise<void>;
+    /**
+     * Export a tracing event - must be implemented by subclasses
+     *
+     * This method is called by exportTracingEvent after checking if the exporter is disabled.
+     */
+    protected abstract _exportTracingEvent(event: TracingEvent): Promise<void>;
+    /**
+     * Optional initialization hook called after Mastra is fully configured
+     */
+    init?(_options: InitExporterOptions): void;
+    /**
+     * Optional method to add scores to traces
+     */
+    addScoreToTrace?(_args: {
+        traceId: string;
+        spanId?: string;
+        score: number;
+        reason?: string;
+        scorerName: string;
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    /**
+     * Force flush any buffered/queued spans without shutting down the exporter.
+     *
+     * This is useful in serverless environments where you need to ensure spans
+     * are exported before the runtime instance is terminated, while keeping
+     * the exporter active for future requests.
+     *
+     * Default implementation is a no-op. Override to add flush logic.
+     */
+    flush(): Promise<void>;
+    /**
+     * Shutdown the exporter and clean up resources
+     *
+     * Default implementation just logs. Override to add custom cleanup.
+     */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/exporters/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/exporters/base.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAiB,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EACV,YAAY,EACZ,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,4BAA4B,CAAC;AAEpC;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,sCAAsC;IACtC,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,mFAAmF;IACnF,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IAC1D;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,8BAAsB,YAAa,YAAW,qBAAqB;;IACjE,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,6BAA6B;IAC7B,SAAS,CAAC,MAAM,EAAE,aAAa,CAAC;IAEhC,oDAAoD;IACpD,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IAKlD,uCAAuC;IACvC,IAAI,UAAU,IAAI,OAAO,CAExB;IAED;;OAEG;gBACS,MAAM,GAAE,kBAAuB;IAQ3C;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAMxC;;OAEG;IACH,OAAO,CAAC,eAAe;IAqBvB;;;;OAIG;IACH,SAAS,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK3C;;;;;;;;;OASG;cACa,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IAoB9E;;;;;;OAMG;IACG,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ5D;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAE1E;;OAEG;IACH,IAAI,CAAC,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI;IAE1C;;OAEG;IACH,eAAe,CAAC,CAAC,KAAK,EAAE;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KAChC,GAAG,OAAO,CAAC,IAAI,CAAC;IAEjB;;;;;;;;OAQG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;;;OAIG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC"}

package/dist/exporters/cloud.d.ts

@@ -0,0 +1,36 @@
+import type { TracingEvent } from '@mastra/core/observability';
+import { BaseExporter } from './base.js';
+import type { BaseExporterConfig } from './base.js';
+export interface CloudExporterConfig extends BaseExporterConfig {
+    maxBatchSize?: number;
+    maxBatchWaitMs?: number;
+    maxRetries?: number;
+    accessToken?: string;
+    endpoint?: string;
+}
+export declare class CloudExporter extends BaseExporter {
+    name: string;
+    private cloudConfig;
+    private buffer;
+    private flushTimer;
+    constructor(config?: CloudExporterConfig);
+    protected _exportTracingEvent(event: TracingEvent): Promise<void>;
+    private addToBuffer;
+    private formatSpan;
+    private shouldFlush;
+    private scheduleFlush;
+    private flushBuffer;
+    /**
+     * Uploads spans to cloud API using fetchWithRetry for all retry logic
+     */
+    private batchUpload;
+    private resetBuffer;
+    /**
+     * Force flush any buffered spans without shutting down the exporter.
+     * This is useful in serverless environments where you need to ensure spans
+     * are exported before the runtime instance is terminated.
+     */
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=cloud.d.ts.map

package/dist/exporters/cloud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud.d.ts","sourceRoot":"","sources":["../../src/exporters/cloud.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,4BAA4B,CAAC;AAEhF,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAEjD,MAAM,WAAW,mBAAoB,SAAQ,kBAAkB;IAC7D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IAGpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAgCD,qBAAa,aAAc,SAAQ,YAAY;IAC7C,IAAI,SAAyC;IAE7C,OAAO,CAAC,WAAW,CAAsB;IACzC,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,UAAU,CAA+B;gBAErC,MAAM,GAAE,mBAAwB;cA2B5B,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBvE,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,UAAU;IAsBlB,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,aAAa;YAoBP,WAAW;IA8CzB;;OAEG;YACW,WAAW;IAezB,OAAO,CAAC,WAAW;IAMnB;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IActB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAkChC"}

package/dist/exporters/console.d.ts

@@ -0,0 +1,10 @@
+import type { TracingEvent } from '@mastra/core/observability';
+import { BaseExporter } from './base.js';
+import type { BaseExporterConfig } from './base.js';
+export declare class ConsoleExporter extends BaseExporter {
+    name: string;
+    constructor(config?: BaseExporterConfig);
+    protected _exportTracingEvent(event: TracingEvent): Promise<void>;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=console.d.ts.map

package/dist/exporters/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../src/exporters/console.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAEjD,qBAAa,eAAgB,SAAQ,YAAY;IAC/C,IAAI,SAA8B;gBAEtB,MAAM,GAAE,kBAAuB;cAI3B,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IA+EjE,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC"}

package/dist/exporters/default.d.ts

@@ -0,0 +1,96 @@
+import type { TracingEvent, InitExporterOptions } from '@mastra/core/observability';
+import type { TracingStorageStrategy } from '@mastra/core/storage';
+import type { BaseExporterConfig } from './base.js';
+import { BaseExporter } from './base.js';
+interface DefaultExporterConfig extends BaseExporterConfig {
+    maxBatchSize?: number;
+    maxBufferSize?: number;
+    maxBatchWaitMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    strategy?: TracingStorageStrategy | 'auto';
+}
+export declare class DefaultExporter extends BaseExporter {
+    #private;
+    name: string;
+    private buffer;
+    private allCreatedSpans;
+    constructor(config?: DefaultExporterConfig);
+    /**
+     * Initialize the exporter (called after all dependencies are ready)
+     */
+    init(options: InitExporterOptions): Promise<void>;
+    /**
+     * Initialize the resolved strategy once observability store is available
+     */
+    private initializeStrategy;
+    /**
+     * Builds a unique span key for tracking
+     */
+    private buildSpanKey;
+    /**
+     * Gets the next sequence number for a span
+     */
+    private getNextSequence;
+    /**
+     * Handles out-of-order span updates by logging and skipping
+     */
+    private handleOutOfOrderUpdate;
+    /**
+     * Adds an event to the appropriate buffer based on strategy
+     */
+    private addToBuffer;
+    /**
+     * Checks if buffer should be flushed based on size or time triggers
+     */
+    private shouldFlush;
+    /**
+     * Resets the buffer after successful flush
+     */
+    private resetBuffer;
+    /**
+     * Schedules a flush using setTimeout
+     */
+    private scheduleFlush;
+    /**
+     * Serializes span attributes to storage record format
+     * Handles all Span types and their specific attributes
+     */
+    private serializeAttributes;
+    private buildCreateRecord;
+    private buildUpdateRecord;
+    /**
+     * Handles realtime strategy - processes each event immediately
+     */
+    private handleRealtimeEvent;
+    /**
+     * Handles batch-with-updates strategy - buffers events and processes in batches
+     */
+    private handleBatchWithUpdatesEvent;
+    /**
+     * Handles insert-only strategy - only processes SPAN_ENDED events in batches
+     */
+    private handleInsertOnlyEvent;
+    /**
+     * Calculates retry delay using exponential backoff
+     */
+    private calculateRetryDelay;
+    /**
+     * Flushes the current buffer to storage with retry logic (internal implementation)
+     */
+    private flushBuffer;
+    /**
+     * Attempts to flush with exponential backoff retry logic
+     */
+    private flushWithRetries;
+    _exportTracingEvent(event: TracingEvent): Promise<void>;
+    /**
+     * Force flush any buffered spans without shutting down the exporter.
+     * This is useful in serverless environments where you need to ensure spans
+     * are exported before the runtime instance is terminated.
+     */
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=default.d.ts.map

package/dist/exporters/default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../src/exporters/default.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAmB,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAErG,OAAO,KAAK,EAKV,sBAAsB,EACvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,UAAU,qBAAsB,SAAQ,kBAAkB;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IAGtB,QAAQ,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAAC;CAC5C;AAmED,qBAAa,eAAgB,SAAQ,YAAY;;IAC/C,IAAI,SAA2C;IAM/C,OAAO,CAAC,MAAM,CAAc;IAI5B,OAAO,CAAC,eAAe,CAA0B;gBAErC,MAAM,GAAE,qBAA0B;IAoC9C;;OAEG;IACG,IAAI,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBvD;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAe1B;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAS9B;;OAEG;IACH,OAAO,CAAC,WAAW;IAgFnB;;OAEG;IACH,OAAO,CAAC,WAAW;IAsBnB;;OAEG;IACH,OAAO,CAAC,WAAW;IAiBnB;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAiC3B,OAAO,CAAC,iBAAiB;IAgDzB,OAAO,CAAC,iBAAiB;IAczB;;OAEG;YACW,mBAAmB;IAyCjC;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAgBnC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAoB7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;OAEG;YACW,WAAW;IAsDzB;;OAEG;YACW,gBAAgB;IA+DxB,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAyB7D;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAStB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAYhC"}

package/dist/exporters/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Mastra Tracing Exporters
+ */
+export * from './base.js';
+export * from './tracking.js';
+export * from './span-formatters.js';
+export * from './cloud.js';
+export * from './console.js';
+export * from './default.js';
+export * from './test.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/exporters/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAG3B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC"}

package/dist/exporters/span-formatters.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Utility functions for working with custom span formatters.
+ */
+import type { CustomSpanFormatter } from '@mastra/core/observability';
+/**
+ * Chains multiple span formatters into a single formatter.
+ *
+ * Formatters are applied in order, with each receiving the output of the previous.
+ * Supports both synchronous and asynchronous formatters - if any formatter returns
+ * a Promise, the entire chain will return a Promise.
+ *
+ * @param formatters - Array of formatters to chain (can be sync or async)
+ * @returns A single formatter that applies all formatters in sequence
+ *
+ * @example
+ * ```typescript
+ * // Chain sync formatters
+ * const chainedFormatter = chainFormatters([
+ *   myPlainTextFormatter,
+ *   myRedactionFormatter,
+ * ]);
+ *
+ * // Chain mixed sync and async formatters
+ * const asyncChainedFormatter = chainFormatters([
+ *   myPlainTextFormatter,     // sync
+ *   myAsyncEnrichmentFormatter, // async
+ * ]);
+ *
+ * const exporter = new BraintrustExporter({
+ *   customSpanFormatter: chainedFormatter,
+ * });
+ * ```
+ */
+export declare function chainFormatters(formatters: CustomSpanFormatter[]): CustomSpanFormatter;
+//# sourceMappingURL=span-formatters.d.ts.map

package/dist/exporters/span-formatters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span-formatters.d.ts","sourceRoot":"","sources":["../../src/exporters/span-formatters.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAmB,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,mBAAmB,EAAE,GAAG,mBAAmB,CAQtF"}

package/dist/exporters/test.d.ts

@@ -0,0 +1,13 @@
+import type { TracingEvent } from '@mastra/core/observability';
+import { BaseExporter } from './base.js';
+import type { BaseExporterConfig } from './base.js';
+export declare class TestExporter extends BaseExporter {
+    #private;
+    name: string;
+    constructor(config?: BaseExporterConfig);
+    protected _exportTracingEvent(event: TracingEvent): Promise<void>;
+    clearEvents(): void;
+    get events(): TracingEvent[];
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=test.d.ts.map

package/dist/exporters/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../src/exporters/test.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAEjD,qBAAa,YAAa,SAAQ,YAAY;;IAC5C,IAAI,SAA2B;gBAGnB,MAAM,GAAE,kBAAuB;cAI3B,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvE,WAAW;IAIX,IAAI,MAAM,IAAI,YAAY,EAAE,CAE3B;IAEK,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC"}