@mastra/observability 0.0.0-trace-timeline-update-20251121114225 → 0.0.0-type-testing-20260120105120

package/README.md

@@ -1,99 +1,54 @@
 # Mastra Observability
 
-A comprehensive observability system for AI operations in Mastra, providing type-safe span tracking, event-driven exports, and flexible tracing configuration.
+Tracing and monitoring for AI operations in Mastra.
 
-## Overview
+## Installation
 
-The Mastra Observability system enables detailed observability for AI-driven applications by tracking operations through spans that capture metadata, timing, and context. It's designed to work seamlessly with Mastra's architecture while providing flexible configuration and export options.
-
-## Key Features
-
-- **Type-Safe Spans**: Strongly typed metadata based on span type prevents runtime errors
-- **Event-Driven Architecture**: Real-time tracing events for immediate observability
-- **OpenTelemetry Compatible**: Uses standard trace and span ID formats for integration
-- **Flexible Sampling**: Multiple sampling strategies with custom sampler support
-- **Pluggable Processors**: Modify or filter span fields before export
-- **Pluggable Exporters**: Multiple export formats and destinations
-- **Automatic Lifecycle Management**: Spans automatically emit events without manual intervention
-
-## Quick Start
-
-### Manual Tracing
-
-```typescript
-import { DefaultObservabilityInstance, SpanType } from '@mastra/observability';
-
-// Create observability instance
-const observability = new DefaultObservabilityInstance({
-  name: 'my-app',
-  serviceName: 'my-app',
-});
-
-// Start an agent span
-const agentSpan = observability.startSpan({
-  type: SpanType.AGENT_RUN,
-  name: 'customer-support-agent',
-  attributes: {
-    agentId: 'agent-123',
-    instructions: 'Help with customer support',
-    maxSteps: 10,
-  },
-});
-
-// Create child spans for nested operations
-const llmSpan = agentSpan.createChildSpan({
-  type: SpanType.MODEL_GENERATION,
-  name: 'gpt-4-response',
-  attributes: {
-    model: 'gpt-4',
-    provider: 'openai',
-    streaming: false,
-  },
-});
-
-// End spans with results
-llmSpan.end({
-  output: 'Generated response',
-  attributes: { usage: { totalTokens: 180 } },
-});
-agentSpan.end();
+```bash
+npm install @mastra/observability
 ```
 
-### Span Types
-
-- **`WORKFLOW_RUN`**: Root span for entire workflow execution
-- **`WORKFLOW_STEP`**: Individual step execution within a workflow
-- **`AGENT_RUN`**: Agent processing (supports tools, memory, multi-step)
-- **`MODEL_GENERATION`**: Individual model API calls with token usage
-- **`TOOL_CALL`**: Function/tool execution
-- **`MCP_TOOL_CALL`**: Model Context Protocol tool execution
-- **`PROCESSOR_RUN`**: Input/output processor execution
-- **`GENERIC`**: Custom spans for other operations
-
-### Basic Configuration
-
-Enable observability in your Mastra instance:
+## Quick Start
 
 ```typescript
 import { Mastra } from '@mastra/core';
-import { Observability } from '@mastra/observability';
+import { Observability, DefaultExporter, CloudExporter, SensitiveDataFilter } from '@mastra/observability';
 
 export const mastra = new Mastra({
-  // ... other config
   observability: new Observability({
-    default: { enabled: true },
+    configs: {
+      default: {
+        serviceName: 'my-app',
+        exporters: [
+          new DefaultExporter(), // Persists traces for Mastra Studio
+          new CloudExporter(), // Sends to Mastra Cloud
+        ],
+        spanOutputProcessors: [new SensitiveDataFilter()],
+      },
+    },
   }),
 });
 ```
 
-This enables the `DefaultExporter` and `CloudExporter`, with the `SensitiveDataFilter` span output processor, and `always` sampling.
+## Features
+
+- **Auto-instrumentation** - Traces agent runs, LLM calls, tool executions, and workflows
+- **Pluggable Exporters** - Exporters for Studio and Cloud, plus integrations for Arize, Braintrust, Langfuse, LangSmith, and OpenTelemetry
+- **Sampling Strategies** - Always, ratio-based, or custom sampling
+- **Span Processors** - Transform or filter span data before export
+- **OpenTelemetry Compatible** - Standard trace/span ID formats for integration
 
-## Performance Considerations
+## Span Types
 
-### Current Implementation
+- `WORKFLOW_RUN` - Workflow execution
+- `WORKFLOW_STEP` - Individual workflow step
+- `AGENT_RUN` - Agent processing
+- `MODEL_GENERATION` - LLM API calls
+- `TOOL_CALL` - Tool execution
+- `MCP_TOOL_CALL` - MCP tool execution
+- `PROCESSOR_RUN` - Processor execution
+- `GENERIC` - Custom operations
 
-The current implementation prioritizes correctness and ease of use:
+## Documentation
 
-- **Automatic Lifecycle Management**: All spans automatically emit events through method wrapping
-- **Real-time Export**: Events are exported immediately when they occur
-- **Memory Overhead**: Each span maintains references to tracing instance
+For configuration options, exporters, sampling strategies, and more, see the [full documentation](https://mastra.ai/docs/v1/observability/overview).

package/dist/config.d.ts

@@ -5,7 +5,7 @@
  * including tracing configs, sampling strategies, and registry setup.
  */
 import type { RequestContext } from '@mastra/core/di';
-import type { ObservabilityInstance, ObservabilityExporter, SpanOutputProcessor, ConfigSelector } from '@mastra/core/observability';
+import type { ObservabilityInstance, ObservabilityExporter, ObservabilityBridge, SpanOutputProcessor, ConfigSelector, SerializationOptions } from '@mastra/core/observability';
 import { z } from 'zod';
 /**
  * Sampling strategy types
@@ -49,6 +49,8 @@ export interface ObservabilityInstanceConfig {
     sampling?: SamplingStrategy;
     /** Custom exporters */
     exporters?: ObservabilityExporter[];
+    /** Observability bridge (e.g., OpenTelemetry bridge for context extraction) */
+    bridge?: ObservabilityBridge;
     /** Custom span output processors */
     spanOutputProcessors?: SpanOutputProcessor[];
     /** Set to `true` if you want to see spans internal to the operation of mastra */
@@ -59,12 +61,21 @@ export interface ObservabilityInstanceConfig {
      * Supports dot notation for nested values.
      */
     requestContextKeys?: string[];
+    /**
+     * Options for controlling serialization of span data (input/output/attributes).
+     * Use these to customize truncation limits for large payloads.
+     */
+    serializationOptions?: SerializationOptions;
 }
 /**
  * Complete Observability registry configuration
  */
 export interface ObservabilityRegistryConfig {
-    /** Enables default exporters, with sampling: always, and sensitive data filtering */
+    /**
+     * Enables default exporters, with sampling: always, and sensitive data filtering
+     * @deprecated Use explicit `configs` with DefaultExporter, CloudExporter, and SensitiveDataFilter instead.
+     * This option will be removed in a future version.
+     */
     default?: {
         enabled?: boolean;
     };
@@ -107,12 +118,31 @@ export declare const samplingStrategySchema: z.ZodDiscriminatedUnion<"type", [z.
     type: SamplingStrategyType.CUSTOM;
     sampler: (args_0: any, ...args: unknown[]) => boolean;
 }>]>;
+/**
+ * Zod schema for SerializationOptions
+ */
+export declare const serializationOptionsSchema: z.ZodOptional<z.ZodObject<{
+    maxStringLength: z.ZodOptional<z.ZodNumber>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    maxArrayLength: z.ZodOptional<z.ZodNumber>;
+    maxObjectKeys: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    maxStringLength?: number | undefined;
+    maxDepth?: number | undefined;
+    maxArrayLength?: number | undefined;
+    maxObjectKeys?: number | undefined;
+}, {
+    maxStringLength?: number | undefined;
+    maxDepth?: number | undefined;
+    maxArrayLength?: number | undefined;
+    maxObjectKeys?: number | undefined;
+}>>;
 /**
  * Zod schema for ObservabilityInstanceConfig
- * Note: exporters, spanOutputProcessors, and configSelector are validated as any
+ * Note: exporters, spanOutputProcessors, bridge, and configSelector are validated as any
  * since they're complex runtime objects
  */
-export declare const observabilityInstanceConfigSchema: z.ZodObject<{
+export declare const observabilityInstanceConfigSchema: z.ZodEffects<z.ZodObject<{
     name: z.ZodString;
     serviceName: z.ZodString;
     sampling: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
@@ -147,9 +177,26 @@ export declare const observabilityInstanceConfigSchema: z.ZodObject<{
         sampler: (args_0: any, ...args: unknown[]) => boolean;
     }>]>>;
     exporters: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    bridge: z.ZodOptional<z.ZodAny>;
     spanOutputProcessors: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
     includeInternalSpans: z.ZodOptional<z.ZodBoolean>;
     requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    serializationOptions: z.ZodOptional<z.ZodObject<{
+        maxStringLength: z.ZodOptional<z.ZodNumber>;
+        maxDepth: z.ZodOptional<z.ZodNumber>;
+        maxArrayLength: z.ZodOptional<z.ZodNumber>;
+        maxObjectKeys: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    }, {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     serviceName: string;
@@ -165,9 +212,66 @@ export declare const observabilityInstanceConfigSchema: z.ZodObject<{
         sampler: (args_0: any, ...args: unknown[]) => boolean;
     } | undefined;
     exporters?: any[] | undefined;
+    bridge?: any;
+    spanOutputProcessors?: any[] | undefined;
+    includeInternalSpans?: boolean | undefined;
+    requestContextKeys?: string[] | undefined;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | undefined;
+}, {
+    name: string;
+    serviceName: string;
+    sampling?: {
+        type: SamplingStrategyType.ALWAYS;
+    } | {
+        type: SamplingStrategyType.NEVER;
+    } | {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    } | {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    } | undefined;
+    exporters?: any[] | undefined;
+    bridge?: any;
     spanOutputProcessors?: any[] | undefined;
     includeInternalSpans?: boolean | undefined;
     requestContextKeys?: string[] | undefined;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | undefined;
+}>, {
+    name: string;
+    serviceName: string;
+    sampling?: {
+        type: SamplingStrategyType.ALWAYS;
+    } | {
+        type: SamplingStrategyType.NEVER;
+    } | {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    } | {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    } | undefined;
+    exporters?: any[] | undefined;
+    bridge?: any;
+    spanOutputProcessors?: any[] | undefined;
+    includeInternalSpans?: boolean | undefined;
+    requestContextKeys?: string[] | undefined;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | undefined;
 }, {
     name: string;
     serviceName: string;
@@ -183,15 +287,22 @@ export declare const observabilityInstanceConfigSchema: z.ZodObject<{
         sampler: (args_0: any, ...args: unknown[]) => boolean;
     } | undefined;
     exporters?: any[] | undefined;
+    bridge?: any;
     spanOutputProcessors?: any[] | undefined;
     includeInternalSpans?: boolean | undefined;
     requestContextKeys?: string[] | undefined;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | undefined;
 }>;
 /**
  * Zod schema for config values in the configs map
  * This is the config object without the name field
  */
-export declare const observabilityConfigValueSchema: z.ZodObject<{
+export declare const observabilityConfigValueSchema: z.ZodEffects<z.ZodObject<{
     serviceName: z.ZodString;
     sampling: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<SamplingStrategyType.ALWAYS>;
@@ -225,9 +336,26 @@ export declare const observabilityConfigValueSchema: z.ZodObject<{
         sampler: (args_0: any, ...args: unknown[]) => boolean;
     }>]>>;
     exporters: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    bridge: z.ZodOptional<z.ZodAny>;
     spanOutputProcessors: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
     includeInternalSpans: z.ZodOptional<z.ZodBoolean>;
     requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    serializationOptions: z.ZodOptional<z.ZodObject<{
+        maxStringLength: z.ZodOptional<z.ZodNumber>;
+        maxDepth: z.ZodOptional<z.ZodNumber>;
+        maxArrayLength: z.ZodOptional<z.ZodNumber>;
+        maxObjectKeys: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    }, {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     serviceName: string;
     sampling?: {
@@ -242,9 +370,64 @@ export declare const observabilityConfigValueSchema: z.ZodObject<{
         sampler: (args_0: any, ...args: unknown[]) => boolean;
     } | undefined;
     exporters?: any[] | undefined;
+    bridge?: any;
+    spanOutputProcessors?: any[] | undefined;
+    includeInternalSpans?: boolean | undefined;
+    requestContextKeys?: string[] | undefined;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | undefined;
+}, {
+    serviceName: string;
+    sampling?: {
+        type: SamplingStrategyType.ALWAYS;
+    } | {
+        type: SamplingStrategyType.NEVER;
+    } | {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    } | {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    } | undefined;
+    exporters?: any[] | undefined;
+    bridge?: any;
+    spanOutputProcessors?: any[] | undefined;
+    includeInternalSpans?: boolean | undefined;
+    requestContextKeys?: string[] | undefined;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | undefined;
+}>, {
+    serviceName: string;
+    sampling?: {
+        type: SamplingStrategyType.ALWAYS;
+    } | {
+        type: SamplingStrategyType.NEVER;
+    } | {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    } | {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    } | undefined;
+    exporters?: any[] | undefined;
+    bridge?: any;
     spanOutputProcessors?: any[] | undefined;
     includeInternalSpans?: boolean | undefined;
     requestContextKeys?: string[] | undefined;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | undefined;
 }, {
     serviceName: string;
     sampling?: {
@@ -259,9 +442,16 @@ export declare const observabilityConfigValueSchema: z.ZodObject<{
         sampler: (args_0: any, ...args: unknown[]) => boolean;
     } | undefined;
     exporters?: any[] | undefined;
+    bridge?: any;
     spanOutputProcessors?: any[] | undefined;
     includeInternalSpans?: boolean | undefined;
     requestContextKeys?: string[] | undefined;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | undefined;
 }>;
 /**
  * Zod schema for ObservabilityRegistryConfig
@@ -269,7 +459,7 @@ export declare const observabilityConfigValueSchema: z.ZodObject<{
  * both plain config objects and pre-instantiated ObservabilityInstance objects.
  * The schema is permissive to handle edge cases gracefully (arrays, null values).
  */
-export declare const observabilityRegistryConfigSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+export declare const observabilityRegistryConfigSchema: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodObject<{
     default: z.ZodNullable<z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
@@ -339,5 +529,25 @@ export declare const observabilityRegistryConfigSchema: z.ZodEffects<z.ZodEffect
     }>>>;
     configs: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>>;
     configSelector: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+    default: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>;
+    configs: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>>;
+    configSelector: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    default: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>;
+    configs: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>>;
+    configSelector: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
 }, z.ZodTypeAny, "passthrough">>;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,EACf,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,oBAAY,oBAAoB;IAC9B,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,KAAK,UAAU;IACf,MAAM,WAAW;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,oBAAoB,CAAC,MAAM,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,oBAAoB,CAAC,KAAK,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACzD;IAAE,IAAI,EAAE,oBAAoB,CAAC,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAA;CAAE,CAAC;AAMhG;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,uBAAuB;IACvB,SAAS,CAAC,EAAE,qBAAqB,EAAE,CAAC;IACpC,oCAAoC;IACpC,oBAAoB,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAC7C,iFAAiF;IACjF,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,qFAAqF;IACrF,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,CAAC;IACF,0FAA0F;IAC1F,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,2BAA2B,EAAE,MAAM,CAAC,GAAG,qBAAqB,CAAC,CAAC;IAC5F,yEAAyE;IACzE,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAMD;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAejC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ5C,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOzC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAiD3C,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACrB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,oBAAY,oBAAoB;IAC9B,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,KAAK,UAAU;IACf,MAAM,WAAW;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,oBAAoB,CAAC,MAAM,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,oBAAoB,CAAC,KAAK,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACzD;IAAE,IAAI,EAAE,oBAAoB,CAAC,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAA;CAAE,CAAC;AAMhG;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,uBAAuB;IACvB,SAAS,CAAC,EAAE,qBAAqB,EAAE,CAAC;IACpC,+EAA+E;IAC/E,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,oCAAoC;IACpC,oBAAoB,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAC7C,iFAAiF;IACjF,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B;;;OAGG;IACH,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,CAAC;IACF,0FAA0F;IAC1F,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,2BAA2B,EAAE,MAAM,CAAC,GAAG,qBAAqB,CAAC,CAAC;IAC5F,yEAAyE;IACzE,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAMD;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAejC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;GAO1B,CAAC;AAEd;;;;GAIG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsB3C,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBxC,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAqE3C,CAAC"}

package/dist/default.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../src/default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAG/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAA+B,2BAA2B,EAAE,MAAM,UAAU,CAAC;AAezF,qBAAa,aAAc,SAAQ,UAAW,YAAW,uBAAuB;;gBAGlE,MAAM,EAAE,2BAA2B;IAsF/C,gBAAgB,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAuBnD,SAAS,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,aAAa,CAAA;KAAE,GAAG,IAAI;IAOnD,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,qBAAqB,GAAG,SAAS;IAItF;;OAEG;IAEH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,qBAAqB,EAAE,SAAS,UAAQ,GAAG,IAAI;IAIxF,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS;IAI5D,kBAAkB,IAAI,qBAAqB,GAAG,SAAS;IAIvD,aAAa,IAAI,WAAW,CAAC,MAAM,EAAE,qBAAqB,CAAC;IAI3D,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIzC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIlC,iBAAiB,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAIjD,KAAK,IAAI,IAAI;IAIP,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC"}
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../src/default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAG/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAA+B,2BAA2B,EAAE,MAAM,UAAU,CAAC;AAezF,qBAAa,aAAc,SAAQ,UAAW,YAAW,uBAAuB;;gBAGlE,MAAM,EAAE,2BAA2B;IA4F/C,gBAAgB,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAuBnD,SAAS,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,aAAa,CAAA;KAAE,GAAG,IAAI;IAOnD,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,qBAAqB,GAAG,SAAS;IAItF;;OAEG;IAEH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,qBAAqB,EAAE,SAAS,UAAQ,GAAG,IAAI;IAIxF,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS;IAI5D,kBAAkB,IAAI,qBAAqB,GAAG,SAAS;IAIvD,aAAa,IAAI,WAAW,CAAC,MAAM,EAAE,qBAAqB,CAAC;IAI3D,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIzC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIlC,iBAAiB,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAIjD,KAAK,IAAI,IAAI;IAIP,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC"}

package/dist/exporters/base.d.ts

@@ -8,7 +8,7 @@
  */
 import { LogLevel } from '@mastra/core/logger';
 import type { IMastraLogger } from '@mastra/core/logger';
-import type { TracingEvent, ObservabilityExporter, InitExporterOptions } from '@mastra/core/observability';
+import type { TracingEvent, ObservabilityExporter, InitExporterOptions, CustomSpanFormatter } from '@mastra/core/observability';
 /**
  * Base configuration that all exporters should support
  */
@@ -17,6 +17,31 @@ export interface BaseExporterConfig {
     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
@@ -49,12 +74,15 @@ export interface BaseExporterConfig {
  * ```
  */
 export declare abstract class BaseExporter implements ObservabilityExporter {
+    #private;
     /** Exporter name - must be implemented by subclasses */
     abstract name: string;
     /** Mastra logger instance */
     protected logger: IMastraLogger;
-    /** Whether this exporter is disabled */
-    protected isDisabled: boolean;
+    /** Base configuration (accessible by subclasses) */
+    protected readonly baseConfig: BaseExporterConfig;
+    /** Public getter for disabled state */
+    get isDisabled(): boolean;
     /**
      * Initialize the base exporter with logger
      */
@@ -73,11 +101,23 @@ export declare abstract class BaseExporter implements ObservabilityExporter {
      * @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 before calling _exportEvent.
-     * Subclasses should implement _exportEvent instead of overriding this method.
+     * 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>;
     /**
@@ -101,6 +141,16 @@ export declare abstract class BaseExporter implements ObservabilityExporter {
         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
      *

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

@@ -1 +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,EAAE,YAAY,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAE3G;;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;CAC3D;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,wCAAwC;IACxC,SAAS,CAAC,UAAU,EAAE,OAAO,CAAS;IAEtC;;OAEG;gBACS,MAAM,GAAE,kBAAuB;IAO3C;;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;;;;;OAKG;IACG,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAO5D;;;;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;;;;OAIG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC"}
+{"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

@@ -10,7 +10,7 @@ export interface CloudExporterConfig extends BaseExporterConfig {
 }
 export declare class CloudExporter extends BaseExporter {
     name: string;
-    private config;
+    private cloudConfig;
     private buffer;
     private flushTimer;
     constructor(config?: CloudExporterConfig);
@@ -19,12 +19,18 @@ export declare class CloudExporter extends BaseExporter {
     private formatSpan;
     private shouldFlush;
     private scheduleFlush;
-    private flush;
+    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

@@ -1 +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;AA0BD,qBAAa,aAAc,SAAQ,YAAY;IAC7C,IAAI,SAAyC;IAE7C,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,UAAU,CAA+B;gBAErC,MAAM,GAAE,mBAAwB;cA8B5B,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,KAAK;IA8CnB;;OAEG;YACW,WAAW;IAezB,OAAO,CAAC,WAAW;IAMb,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAuChC"}
+{"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"}