@mastra/mcp-docs-server 0.13.17-alpha.3 → 0.13.17-alpha.4

package/.docs/raw/reference/scorers/prompt-alignment.mdx

@@ -0,0 +1,369 @@
+---
+title: "Reference: Prompt Alignment Scorer | Scorers | Mastra Docs"
+description: Documentation for the Prompt Alignment Scorer in Mastra. Evaluates how well agent responses align with user prompt intent, requirements, completeness, and appropriateness using multi-dimensional analysis.
+---
+
+import { PropertiesTable } from "@/components/properties-table";
+
+# Prompt Alignment Scorer
+
+The `createPromptAlignmentScorerLLM()` function creates a scorer that evaluates how well agent responses align with user prompts across multiple dimensions: intent understanding, requirement fulfillment, response completeness, and format appropriateness.
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "model",
+      type: "MastraLanguageModel",
+      description: "The language model to use for evaluating prompt-response alignment",
+      required: true,
+    },
+    {
+      name: "options",
+      type: "PromptAlignmentOptions",
+      description: "Configuration options for the scorer",
+      required: false,
+      children: [
+        {
+          name: "scale",
+          type: "number",
+          description: "Scale factor to multiply the final score (default: 1)",
+          required: false,
+        },
+        {
+          name: "evaluationMode",
+          type: "'user' | 'system' | 'both'",
+          description: "Evaluation mode - 'user' evaluates user prompt alignment only, 'system' evaluates system compliance only, 'both' evaluates both with weighted scoring (default: 'both')",
+          required: false,
+        },
+      ],
+    },
+  ]}
+/>
+
+## .run() Returns
+
+<PropertiesTable
+  content={[
+    {
+      name: "score",
+      type: "number",
+      description: "Multi-dimensional alignment score between 0 and scale (default 0-1)",
+    },
+    {
+      name: "reason",
+      type: "string",
+      description: "Human-readable explanation of the prompt alignment evaluation with detailed breakdown",
+    },
+  ]}
+/>
+
+## Scoring Details
+
+### Multi-Dimensional Analysis
+
+Prompt Alignment evaluates responses across four key dimensions with weighted scoring that adapts based on the evaluation mode:
+
+#### User Mode ('user')
+Evaluates alignment with user prompts only:
+
+1. **Intent Alignment** (40% weight) - Whether the response addresses the user's core request
+2. **Requirements Fulfillment** (30% weight) - If all user requirements are met
+3. **Completeness** (20% weight) - Whether the response is comprehensive for user needs  
+4. **Response Appropriateness** (10% weight) - If format and tone match user expectations
+
+#### System Mode ('system')
+Evaluates compliance with system guidelines only:
+
+1. **Intent Alignment** (35% weight) - Whether the response follows system behavioral guidelines
+2. **Requirements Fulfillment** (35% weight) - If all system constraints are respected
+3. **Completeness** (15% weight) - Whether the response adheres to all system rules
+4. **Response Appropriateness** (15% weight) - If format and tone match system specifications
+
+#### Both Mode ('both' - default)
+Combines evaluation of both user and system alignment:
+
+- **User alignment**: 70% of final score (using user mode weights)
+- **System compliance**: 30% of final score (using system mode weights)
+- Provides balanced assessment of user satisfaction and system adherence
+
+### Scoring Formula
+
+**User Mode:**
+```
+Weighted Score = (intent_score × 0.4) + (requirements_score × 0.3) + 
+                 (completeness_score × 0.2) + (appropriateness_score × 0.1)
+Final Score = Weighted Score × scale
+```
+
+**System Mode:**
+```
+Weighted Score = (intent_score × 0.35) + (requirements_score × 0.35) + 
+                 (completeness_score × 0.15) + (appropriateness_score × 0.15)
+Final Score = Weighted Score × scale
+```
+
+**Both Mode (default):**
+```
+User Score = (user dimensions with user weights)
+System Score = (system dimensions with system weights)  
+Weighted Score = (User Score × 0.7) + (System Score × 0.3)
+Final Score = Weighted Score × scale
+```
+
+**Weight Distribution Rationale**:
+- **User Mode**: Prioritizes intent (40%) and requirements (30%) for user satisfaction
+- **System Mode**: Balances behavioral compliance (35%) and constraints (35%) equally
+- **Both Mode**: 70/30 split ensures user needs are primary while maintaining system compliance
+
+### Score Interpretation
+
+- **0.9-1.0** = Excellent alignment across all dimensions
+- **0.8-0.9** = Very good alignment with minor gaps
+- **0.7-0.8** = Good alignment but missing some requirements or completeness
+- **0.6-0.7** = Moderate alignment with noticeable gaps
+- **0.4-0.6** = Poor alignment with significant issues
+- **0.0-0.4** = Very poor alignment, response doesn't address the prompt effectively
+
+### Comparison with Other Scorers
+
+| Aspect | Prompt Alignment | Answer Relevancy | Faithfulness |
+|--------|------------------|------------------|--------------|
+| **Focus** | Multi-dimensional prompt adherence | Query-response relevance | Context groundedness |
+| **Evaluation** | Intent, requirements, completeness, format | Semantic similarity to query | Factual consistency with context |
+| **Use Case** | General prompt following | Information retrieval | RAG/context-based systems |
+| **Dimensions** | 4 weighted dimensions | Single relevance dimension | Single faithfulness dimension |
+
+### When to Use Each Mode
+
+**User Mode (`'user'`)** - Use when:
+- Evaluating customer service responses for user satisfaction
+- Testing content generation quality from user perspective  
+- Measuring how well responses address user questions
+- Focusing purely on request fulfillment without system constraints
+
+**System Mode (`'system'`)** - Use when:
+- Auditing AI safety and compliance with behavioral guidelines
+- Ensuring agents follow brand voice and tone requirements
+- Validating adherence to content policies and constraints
+- Testing system-level behavioral consistency
+
+**Both Mode (`'both'`)** - Use when (default, recommended):
+- Comprehensive evaluation of overall AI agent performance
+- Balancing user satisfaction with system compliance
+- Production monitoring where both user and system requirements matter
+- Holistic assessment of prompt-response alignment
+
+## Usage Examples
+
+### Basic Configuration
+
+```typescript
+import { openai } from '@ai-sdk/openai';
+import { createPromptAlignmentScorerLLM } from '@mastra/evals';
+
+const scorer = createPromptAlignmentScorerLLM({
+  model: openai('gpt-4o'),
+});
+
+// Evaluate a code generation task
+const result = await scorer.run({
+  input: [{
+    role: 'user',
+    content: 'Write a Python function to calculate factorial with error handling'
+  }],
+  output: {
+    role: 'assistant', 
+    text: `def factorial(n):
+    if n < 0:
+        raise ValueError("Factorial not defined for negative numbers")
+    if n == 0:
+        return 1
+    return n * factorial(n-1)`
+  }
+});
+// Result: { score: 0.95, reason: "Excellent alignment - function addresses intent, includes error handling..." }
+```
+
+### Custom Configuration Examples
+
+```typescript
+// Configure scale and evaluation mode
+const scorer = createPromptAlignmentScorerLLM({
+  model: openai('gpt-4o'),
+  options: {
+    scale: 10, // Score from 0-10 instead of 0-1
+    evaluationMode: 'both' // 'user', 'system', or 'both' (default)
+  },
+});
+
+// User-only evaluation - focus on user satisfaction
+const userScorer = createPromptAlignmentScorerLLM({
+  model: openai('gpt-4o'),
+  options: { evaluationMode: 'user' }
+});
+
+// System-only evaluation - focus on compliance
+const systemScorer = createPromptAlignmentScorerLLM({
+  model: openai('gpt-4o'),
+  options: { evaluationMode: 'system' }
+});
+
+const result = await scorer.run(testRun);
+// Result: { score: 8.5, reason: "Score: 8.5 out of 10 - Good alignment with both user intent and system guidelines..." }
+```
+
+### Format-Specific Evaluation
+
+```typescript
+// Evaluate bullet point formatting
+const result = await scorer.run({
+  input: [{
+    role: 'user',
+    content: 'List the benefits of TypeScript in bullet points'
+  }],
+  output: {
+    role: 'assistant',
+    text: 'TypeScript provides static typing, better IDE support, and enhanced code reliability.'
+  }
+});
+// Result: Lower appropriateness score due to format mismatch (paragraph vs bullet points)
+```
+
+## Usage Patterns
+
+### Code Generation Evaluation
+Ideal for evaluating:
+- Programming task completion
+- Code quality and completeness  
+- Adherence to coding requirements
+- Format specifications (functions, classes, etc.)
+
+```typescript
+// Example: API endpoint creation
+const codePrompt = "Create a REST API endpoint with authentication and rate limiting";
+// Scorer evaluates: intent (API creation), requirements (auth + rate limiting), 
+// completeness (full implementation), format (code structure)
+```
+
+### Instruction Following Assessment
+Perfect for:
+- Task completion verification
+- Multi-step instruction adherence
+- Requirement compliance checking
+- Educational content evaluation
+
+```typescript
+// Example: Multi-requirement task
+const taskPrompt = "Write a Python class with initialization, validation, error handling, and documentation";
+// Scorer tracks each requirement individually and provides detailed breakdown
+```
+
+### Content Format Validation
+Useful for:
+- Format specification compliance
+- Style guide adherence
+- Output structure verification
+- Response appropriateness checking
+
+```typescript
+// Example: Structured output
+const formatPrompt = "Explain the differences between let and const in JavaScript using bullet points";
+// Scorer evaluates content accuracy AND format compliance
+```
+
+## Common Use Cases
+
+### 1. Agent Response Quality
+Measure how well your AI agents follow user instructions:
+
+```typescript
+const agent = new Agent({
+  name: 'CodingAssistant',
+  instructions: 'You are a helpful coding assistant. Always provide working code examples.',
+  model: openai('gpt-4o'),
+});
+
+// Evaluate comprehensive alignment (default)
+const scorer = createPromptAlignmentScorerLLM({
+  model: openai('gpt-4o-mini'),
+  options: { evaluationMode: 'both' } // Evaluates both user intent and system guidelines
+});
+
+// Evaluate just user satisfaction
+const userScorer = createPromptAlignmentScorerLLM({
+  model: openai('gpt-4o-mini'),
+  options: { evaluationMode: 'user' } // Focus only on user request fulfillment
+});
+
+// Evaluate system compliance
+const systemScorer = createPromptAlignmentScorerLLM({
+  model: openai('gpt-4o-mini'),
+  options: { evaluationMode: 'system' } // Check adherence to system instructions
+});
+
+const result = await scorer.run(agentRun);
+```
+
+### 2. Prompt Engineering Optimization
+Test different prompts to improve alignment:
+
+```typescript
+const prompts = [
+  'Write a function to calculate factorial',
+  'Create a Python function that calculates factorial with error handling for negative inputs',
+  'Implement a factorial calculator in Python with: input validation, error handling, and docstring'
+];
+
+// Compare alignment scores to find the best prompt
+for (const prompt of prompts) {
+  const result = await scorer.run(createTestRun(prompt, response));
+  console.log(`Prompt alignment: ${result.score}`);
+}
+```
+
+### 3. Multi-Agent System Evaluation
+Compare different agents or models:
+
+```typescript
+const agents = [agent1, agent2, agent3];
+const testPrompts = [...]; // Array of test prompts
+
+for (const agent of agents) {
+  let totalScore = 0;
+  for (const prompt of testPrompts) {
+    const response = await agent.run(prompt);
+    const evaluation = await scorer.run({ input: prompt, output: response });
+    totalScore += evaluation.score;
+  }
+  console.log(`${agent.name} average alignment: ${totalScore / testPrompts.length}`);
+}
+```
+
+## Error Handling
+
+The scorer handles various edge cases gracefully:
+
+```typescript
+// Missing user prompt
+try {
+  await scorer.run({ input: [], output: response });
+} catch (error) {
+  // Error: "Both user prompt and agent response are required for prompt alignment scoring"
+}
+
+// Empty response
+const result = await scorer.run({ 
+  input: [userMessage], 
+  output: { role: 'assistant', text: '' } 
+});
+// Returns low scores with detailed reasoning about incompleteness
+```
+
+## Related
+
+- [Answer Relevancy Scorer](/reference/scorers/answer-relevancy) - Evaluates query-response relevance
+- [Faithfulness Scorer](/reference/scorers/faithfulness) - Measures context groundedness
+- [Tool Call Accuracy Scorer](/reference/scorers/tool-call-accuracy) - Evaluates tool selection
+- [Custom Scorers](/docs/scorers/custom-scorers) - Creating your own evaluation metrics

package/.docs/raw/scorers/off-the-shelf-scorers.mdx

@@ -20,6 +20,7 @@ These scorers evaluate how correct, truthful, and complete your agent's answers
 - [`content-similarity`](/reference/scorers/content-similarity): Measures textual similarity using character-level matching (`0-1`, higher is better)
 - [`textual-difference`](/reference/scorers/textual-difference): Measures textual differences between strings (`0-1`, higher means more similar)
 - [`tool-call-accuracy`](/reference/scorers/tool-call-accuracy): Evaluates whether the LLM selects the correct tool from available options (`0-1`, higher is better)
+- [`prompt-alignment`](/reference/scorers/prompt-alignment): Measures how well agent responses align with user prompt intent, requirements, completeness, and format (`0-1`, higher is better)
 
 ### Context Quality
 
@@ -28,14 +29,13 @@ These scorers evaluate the quality and relevance of context used in generating r
 - [`context-precision`](/reference/scorers/context-precision): Evaluates context relevance and ranking using Mean Average Precision, rewarding early placement of relevant context (`0-1`, higher is better)
 - [`context-relevance`](/reference/scorers/context-relevance): Measures context utility with nuanced relevance levels, usage tracking, and missing context detection (`0-1`, higher is better)
 
-:::tip Context Scorer Selection
+> tip Context Scorer Selection
 - Use **Context Precision** when context ordering matters and you need standard IR metrics (ideal for RAG ranking evaluation)
 - Use **Context Relevance** when you need detailed relevance assessment and want to track context usage and identify gaps
 
 Both context scorers support:
 - **Static context**: Pre-defined context arrays
 - **Dynamic context extraction**: Extract context from runs using custom functions (ideal for RAG systems, vector databases, etc.)
-:::
 
 ### Output Quality
 

package/.docs/raw/streaming/overview.mdx

@@ -15,8 +15,8 @@ Mastra supports real-time, incremental responses from agents and workflows, allo
 
 Mastra currently supports two streaming methods, this page explains how to use `streamVNext()`.
 
-1. **`.stream()`**: Current stable API, supports **AI SDK v1**.
-2. **`.streamVNext()`**: Experimental API, supports **AI SDK v2**.
+1. **`.stream()`**: Current stable API, supports **AI SDK v4** (`LanguageModelV1`).
+2. **`.streamVNext()`**: Experimental API, supports **AI SDK v5** (`LanguageModelV2`).
 
 ## Streaming with agents
 

package/.docs/raw/streaming/tool-streaming.mdx

@@ -3,6 +3,8 @@ title: "Tool Streaming | Streaming | Mastra"
 description: "Learn how to use tool streaming in Mastra, including handling tool calls, tool results, and tool execution events during streaming."
 ---
 
+import { Callout } from "nextra/components";
+
 # Tool streaming
 
 Tool streaming in Mastra enables tools to send incremental results while they run, rather than waiting until execution finishes. This allows you to surface partial progress, intermediate states, or progressive data directly to users or upstream agents and workflows.
@@ -36,6 +38,10 @@ export const testAgent = new Agent({
 
 The `writer` argument is passed to a tool’s `execute` function and can be used to emit custom events, data, or values into the active stream. This enables tools to provide intermediate results or status updates while execution is still in progress.
 
+<Callout type="warning">
+You must `await` the call to `writer.write(...)` or else you will lock the stream and get a `WritableStream is locked` error.
+</Callout>
+
 ```typescript {5,8,15} showLineNumbers copy
 import { createTool } from "@mastra/core/tools";
 
@@ -44,14 +50,14 @@ export const testTool = createTool({
   execute: async ({ context, writer }) => {
     const { value } = context;
 
-    writer?.write({
+   await writer?.write({
       type: "custom-event",
       status: "pending"
     });
 
     const response = await fetch(...);
 
-    writer?.write({
+   await writer?.write({
       type: "custom-event",
       status: "success"
     });

package/.docs/raw/streaming/workflow-streaming.mdx

@@ -3,6 +3,8 @@ title: "Workflow Streaming | Streaming | Mastra"
 description: "Learn how to use workflow streaming in Mastra, including handling workflow execution events, step streaming, and workflow integration with agents and tools."
 ---
 
+import { Callout } from "nextra/components";
+
 # Workflow streaming
 
 Workflow streaming in Mastra enables workflows to send incremental results while they execute, rather than waiting until completion. This allows you to surface partial progress, intermediate states, or progressive data directly to users or upstream agents and workflows.
@@ -18,6 +20,10 @@ By combining writable workflow streams with agent streaming, you gain fine-grain
 
 The `writer` argument is passed to a workflow step's `execute` function and can be used to emit custom events, data, or values into the active stream. This enables workflow steps to provide intermediate results or status updates while execution is still in progress.
 
+<Callout type="warning">
+You must `await` the call to `writer.write(...)` or else you will lock the stream and get a `WritableStream is locked` error.
+</Callout>
+
 ```typescript {5,8,15} showLineNumbers copy
 import { createStep } from "@mastra/core/workflows";
 
@@ -26,14 +32,14 @@ export const testStep = createStep({
   execute: async ({ inputData, writer }) => {
      const { value } = inputData;
 
-    writer?.write({
+    await writer?.write({
       type: "custom-event",
       status: "pending"
     });
 
     const response = await fetch(...);
 
-    writer?.write({
+   await writer?.write({
       type: "custom-event",
       status: "success"
     });

package/.docs/raw/tools-mcp/overview.mdx

@@ -3,6 +3,8 @@ title: "Tools Overview | Tools & MCP | Mastra Docs"
 description: Understand what tools are in Mastra, how to add them to agents, and best practices for designing effective tools.
 ---
 
+import { Steps } from "nextra/components";
+
 # Tools Overview
 
 Tools are functions that agents can execute to perform specific tasks or access external information. They extend an agent's capabilities beyond simple text generation, allowing interaction with APIs, databases, or other systems.
@@ -65,3 +67,45 @@ Some providers that we include this layer for:
 - **DeepSeek & Meta:** Apply similar compatibility logic to ensure schema alignment and tool usability.
 
 This approach makes tool usage more reliable and model-agnostic for both custom and MCP tools.
+
+
+## Testing tools locally
+There are two ways to run and test tools.
+
+<Steps>
+
+### Mastra Playground
+
+With the Mastra Dev Server running you can test a tool from the Mastra Playground by visiting [http://localhost:4111/tools](http://localhost:4111/tools) in your browser.
+
+> For more information, see the [Local Dev Playground](/docs/server-db/local-dev-playground) documentation.
+
+### Command line
+
+Invoke a tool using `.execute()`.
+
+```typescript filename="src/test-tool.ts" showLineNumbers copy
+import { RuntimeContext } from "@mastra/core/runtime-context";
+import { testTool } from "./mastra/tools/test-tool";
+
+const runtimeContext = new RuntimeContext();
+
+const result = await testTool.execute({
+  context: {
+    value: "foo"
+  },
+  runtimeContext
+});
+
+console.log(result);
+```
+
+> See [createTool()](../../reference/tools/create-tool.mdx) for more information.
+
+To test this tool, run the following:
+
+```bash copy
+npx tsx src/test-tool.ts
+```
+
+</Steps>

package/.docs/raw/workflows/overview.mdx

@@ -130,7 +130,7 @@ export const testWorkflow = createWorkflow({
   .commit();
 ```
 
-### Register workflow
+## Register workflow
 
 Register a workflow using `workflows` in the main Mastra instance:
 
@@ -154,20 +154,24 @@ export const mastra = new Mastra({
 });
 ```
 
-### Run workflow
+## Testing workflows locally
 There are two ways to run and test workflows.
 
 <Steps>
 
-#### Mastra Playground
+### Mastra Playground
 
 With the Mastra Dev Server running you can run the workflow from the Mastra Playground by visiting [http://localhost:4111/workflows](http://localhost:4111/workflows) in your browser.
 
-#### Command line
+> For more information, see the [Local Dev Playground](/docs/server-db/local-dev-playground) documentation.
 
-Create a run instance of any Mastra workflow using `createRunAsync` and `start`:
+### Command line
+
+Create a workflow run instance using `createRunAsync` and `start`:
 
 ```typescript {3,5} filename="src/test-workflow.ts" showLineNumbers copy
+import "dotenv/config";
+
 import { mastra } from "./mastra";
 
 const run = await mastra.getWorkflow("testWorkflow").createRunAsync();
@@ -178,15 +182,13 @@ const result = await run.start({
   }
 });
 
-// Dump the complete workflow result (includes status, steps and result)
-console.log(JSON.stringify(result, null, 2));
+console.log(result);
 
-// Get the workflow output value
 if (result.status === 'success') {
-  console.log(`output value: ${result.result.output}`);
+  console.log(result.result.output);
 }
 ```
-> see [createRunAsync](/reference/workflows/create-run) and [start](/reference/workflows/run-methods/start) for more information.
+> see [createRunAsync](../../reference/workflows/create-run.mdx) and [start](../../reference/workflows/run-methods/start.mdx) for more information.
 
 To trigger this workflow, run the following:
 
@@ -196,11 +198,11 @@ npx tsx src/test-workflow.ts
 
 </Steps>
 
-#### Run workflow results
+### Run workflow results
 
 The result of running a workflow using either `start()` or `resume()` will look like one of the following, depending on the outcome.
 
-##### Status success
+#### Status success
 
 ```json
 {
@@ -224,7 +226,7 @@ The result of running a workflow using either `start()` or `resume()` will look
 - **result**: Includes the final output of the workflow, typed according to the `outputSchema`
 
 
-##### Status suspended
+#### Status suspended
 
 ```json
 {
@@ -246,7 +248,7 @@ The result of running a workflow using either `start()` or `resume()` will look
 
 - **suspended**: An optional array listing any steps currently awaiting input before continuing
 
-##### Status failed
+#### Status failed
 
 ```json
 {
@@ -264,7 +266,7 @@ The result of running a workflow using either `start()` or `resume()` will look
 ```
 - **error**: An optional field that includes the error message if the workflow fails
 
-### Stream workflow
+## Stream workflow
 
 Similar to the run method shown above, workflows can also be streamed:
 
@@ -286,7 +288,7 @@ for await (const chunk of result.stream) {
 
 > See [stream](/reference/workflows/run-methods/stream) and [messages](/reference/workflows/run-methods/stream#messages) for more information.
 
-### Watch Workflow
+## Watch Workflow
 
 A workflow can also be watched, allowing you to inspect each event that is emitted.
 
@@ -308,7 +310,7 @@ const result = await run.start({
 
 > See [watch](/reference/workflows/run-methods/watch) for more information.
 
-## More resources
+## Related
 
 - The [Workflow Guide](../../guides/guide/ai-recruiter.mdx) in the Guides section is a tutorial that covers the main concepts.
 - [Parallel Steps workflow example](../../examples/workflows/parallel-steps.mdx)

package/dist/stdio.js

@@ -798,7 +798,11 @@ async function listDirContents(dirPath) {
   }
 }
 async function readMdxContent(docPath, queryKeywords) {
-  const fullPath = path3__default.join(docsBaseDir, docPath);
+  const fullPath = path3__default.resolve(path3__default.join(docsBaseDir, docPath));
+  if (!fullPath.startsWith(path3__default.resolve(docsBaseDir))) {
+    void logger.error(`Path traversal attempt detected`);
+    return { found: false };
+  }
   void logger.debug(`Reading MDX content from: ${fullPath}`);
   try {
     const stats = await fs3.stat(fullPath);

package/dist/tools/docs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/tools/docs.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA4JxB,eAAO,MAAM,eAAe;;;;;;;;;EAW1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;oBAkBG,SAAS;CAiDhC,CAAC"}
+{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/tools/docs.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgKxB,eAAO,MAAM,eAAe;;;;;;;;;EAW1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;oBAkBG,SAAS;CAiDhC,CAAC"}