agentic-flow 2.0.2-alpha → 2.0.2

package/dist/reasoningbank/core/memory-engine.js

@@ -0,0 +1,335 @@
+/**
+ * ReasoningBank Memory Engine
+ * Implements the 4-phase learning loop: RETRIEVE → JUDGE → DISTILL → CONSOLIDATE
+ */
+import { ReasoningBankDB } from './database.js';
+import { createEmbeddingProvider, cosineSimilarity } from '../utils/embeddings.js';
+import { piiScrubber } from '../utils/pii-scrubber.js';
+export class ReasoningBankEngine {
+    db;
+    embeddings;
+    piiEnabled;
+    weights;
+    defaultK;
+    minConfidence;
+    consolidationThreshold;
+    memoriesSinceConsolidation = 0;
+    constructor(config) {
+        this.db = new ReasoningBankDB(config.dbPath);
+        this.embeddings = createEmbeddingProvider(config.embeddings?.provider || 'hash', {
+            apiKey: process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY,
+            model: config.embeddings?.model
+        });
+        this.piiEnabled = config.piiScrub?.enabled !== false;
+        this.weights = {
+            alpha: config.retrieval?.weights?.alpha || 0.65, // Similarity
+            beta: config.retrieval?.weights?.beta || 0.15, // Recency
+            gamma: config.retrieval?.weights?.gamma || 0.20, // Reliability
+            delta: config.retrieval?.weights?.delta || 0.10 // Diversity penalty
+        };
+        this.defaultK = config.retrieval?.k || 3;
+        this.minConfidence = config.retrieval?.minConfidence || 0.3;
+        this.consolidationThreshold = config.consolidation?.scheduleEvery || 20;
+    }
+    /**
+     * Phase 1: RETRIEVE - Get relevant memories using 4-factor scoring
+     */
+    async retrieve(options) {
+        const k = options.k || this.defaultK;
+        const lambda = options.lambda || 0.9;
+        // Generate query embedding
+        const queryEmbedding = await this.embeddings.generate(options.query);
+        // Get all memories
+        const allMemories = this.db.getAllMemories();
+        const embeddings = this.db.getAllEmbeddings();
+        // Filter by domain if specified
+        let candidates = allMemories;
+        if (options.domain) {
+            candidates = candidates.filter(m => m.pattern_data.domain === options.domain ||
+                m.pattern_data.domain?.startsWith(options.domain + '.'));
+        }
+        // Calculate scores for each candidate
+        const scoredCandidates = [];
+        for (const memory of candidates) {
+            const embedding = embeddings.get(memory.id);
+            if (!embedding)
+                continue;
+            // 1. Similarity score (cosine similarity)
+            const similarity = cosineSimilarity(queryEmbedding, embedding);
+            // 2. Recency score (exponential decay, 30-day half-life)
+            const ageDays = (Date.now() - new Date(memory.created_at).getTime()) / (1000 * 60 * 60 * 24);
+            const recency = Math.exp(-ageDays / 30);
+            // 3. Reliability score (confidence × sqrt(usage/10))
+            const reliability = Math.min(memory.confidence * Math.sqrt(memory.usage_count / 10), 1.0);
+            // Combined score (before diversity penalty)
+            const score = this.weights.alpha * similarity +
+                this.weights.beta * recency +
+                this.weights.gamma * reliability;
+            scoredCandidates.push({
+                ...memory,
+                score,
+                similarity,
+                recency,
+                reliability,
+                diversityPenalty: 0 // Will be calculated in MMR
+            });
+        }
+        // Sort by score
+        scoredCandidates.sort((a, b) => b.score - a.score);
+        // Apply MMR for diversity
+        const selected = this.selectWithMMR(scoredCandidates, queryEmbedding, k, lambda);
+        // Update usage counts
+        for (const memory of selected) {
+            this.db.updateMemoryUsage(memory.id);
+        }
+        // Filter by minimum confidence
+        return selected.filter(m => m.confidence >= this.minConfidence);
+    }
+    /**
+     * MMR (Maximal Marginal Relevance) Selection
+     * Balances relevance and diversity
+     */
+    selectWithMMR(candidates, queryEmbedding, k, lambda) {
+        const selected = [];
+        const remaining = [...candidates];
+        const embeddings = this.db.getAllEmbeddings();
+        while (selected.length < k && remaining.length > 0) {
+            let bestScore = -Infinity;
+            let bestIndex = -1;
+            for (let i = 0; i < remaining.length; i++) {
+                const candidate = remaining[i];
+                const candidateEmbedding = embeddings.get(candidate.id);
+                if (!candidateEmbedding)
+                    continue;
+                // Relevance to query
+                const relevance = candidate.score;
+                // Maximum similarity to already selected
+                let maxSimilarity = 0;
+                if (selected.length > 0) {
+                    for (const selectedMemory of selected) {
+                        const selectedEmbedding = embeddings.get(selectedMemory.id);
+                        if (selectedEmbedding) {
+                            const sim = cosineSimilarity(candidateEmbedding, selectedEmbedding);
+                            maxSimilarity = Math.max(maxSimilarity, sim);
+                        }
+                    }
+                }
+                // MMR score
+                const mmrScore = lambda * relevance - (1 - lambda) * maxSimilarity;
+                if (mmrScore > bestScore) {
+                    bestScore = mmrScore;
+                    bestIndex = i;
+                }
+            }
+            if (bestIndex >= 0) {
+                selected.push(remaining[bestIndex]);
+                remaining.splice(bestIndex, 1);
+            }
+            else {
+                break;
+            }
+        }
+        return selected;
+    }
+    /**
+     * Phase 2: JUDGE - Evaluate task outcome
+     */
+    async judge(trajectory) {
+        // Simple heuristic judge (can be upgraded to LLM)
+        const scrubbed = this.piiEnabled ? piiScrubber.scrub(trajectory) : trajectory;
+        // Heuristics for success/failure
+        const errorKeywords = ['error', 'failed', 'exception', 'timeout', 'unauthorized', 'forbidden'];
+        const successKeywords = ['success', 'completed', 'ok', '200', 'done'];
+        const lowerTrajectory = scrubbed.toLowerCase();
+        const hasError = errorKeywords.some(kw => lowerTrajectory.includes(kw));
+        const hasSuccess = successKeywords.some(kw => lowerTrajectory.includes(kw));
+        if (hasSuccess && !hasError) {
+            return { label: 'Success', confidence: 0.8, rationale: 'Success keywords found' };
+        }
+        else if (hasError && !hasSuccess) {
+            return { label: 'Failure', confidence: 0.8, rationale: 'Error keywords found' };
+        }
+        else if (hasSuccess && hasError) {
+            return { label: 'Success', confidence: 0.5, rationale: 'Mixed signals' };
+        }
+        else {
+            return { label: 'Failure', confidence: 0.5, rationale: 'No clear indicators' };
+        }
+    }
+    /**
+     * Phase 3: DISTILL - Extract patterns from trajectory
+     */
+    async distill(taskId, trajectory, verdict, domain) {
+        const scrubbed = this.piiEnabled ? piiScrubber.scrub(trajectory) : trajectory;
+        // Store trajectory
+        this.db.insertTrajectory({
+            task_id: taskId,
+            trajectory: scrubbed,
+            verdict: verdict.label,
+            confidence: verdict.confidence
+        });
+        // Extract pattern based on verdict
+        const pattern = verdict.label === 'Success'
+            ? this.extractSuccessPattern(scrubbed, domain)
+            : this.extractFailureGuardrail(scrubbed, domain);
+        // Store as memory
+        const memoryId = this.db.insertMemory({
+            title: pattern.title,
+            description: pattern.description,
+            content: pattern.content,
+            confidence: verdict.confidence,
+            usage_count: 0,
+            pattern_data: {
+                domain,
+                success_pattern: verdict.label === 'Success',
+                failure_guardrail: verdict.label === 'Failure'
+            }
+        });
+        // Generate and store embedding
+        const embedding = await this.embeddings.generate(pattern.content);
+        this.db.insertEmbedding(memoryId, embedding);
+        this.memoriesSinceConsolidation++;
+        return memoryId;
+    }
+    extractSuccessPattern(trajectory, domain) {
+        // Extract key steps from successful execution
+        const lines = trajectory.split('\n').filter(l => l.trim());
+        const keySteps = lines.slice(0, 5).join('\n');
+        return {
+            title: `Success pattern for ${domain}`,
+            description: `Successful execution strategy`,
+            content: `Successful approach:\n${keySteps}`
+        };
+    }
+    extractFailureGuardrail(trajectory, domain) {
+        // Extract error information
+        const lines = trajectory.split('\n').filter(l => l.trim());
+        const errorInfo = lines.find(l => l.toLowerCase().includes('error') ||
+            l.toLowerCase().includes('failed')) || 'Unknown error';
+        return {
+            title: `Failure guardrail for ${domain}`,
+            description: `Prevention strategy for common failures`,
+            content: `Avoid: ${errorInfo}\nRecommend: Check prerequisites and retry with backoff`
+        };
+    }
+    /**
+     * Phase 4: CONSOLIDATE - Deduplicate and prune
+     */
+    async consolidate(options) {
+        const startTime = Date.now();
+        const dedupeThreshold = options?.dedupeThreshold || 0.95;
+        const maxAgeDays = options?.prune?.maxAgeDays || 90;
+        const minConfidence = options?.prune?.minConfidence || 0.3;
+        const unusedDays = options?.prune?.unusedDays || 30;
+        // Find and merge duplicates
+        const duplicates = this.db.findDuplicates(dedupeThreshold);
+        for (const [id1, id2] of duplicates) {
+            const mem1 = this.db.getMemory(id1);
+            const mem2 = this.db.getMemory(id2);
+            if (mem1 && mem2) {
+                // Keep the one with higher confidence and usage
+                const keepId = mem1.confidence > mem2.confidence ||
+                    (mem1.confidence === mem2.confidence && mem1.usage_count > mem2.usage_count)
+                    ? id1 : id2;
+                const deleteId = keepId === id1 ? id2 : id1;
+                this.db.deleteMemory(deleteId);
+            }
+        }
+        // Prune old or low-quality memories
+        const allMemories = this.db.getAllMemories();
+        let pruned = 0;
+        for (const memory of allMemories) {
+            const ageDays = (Date.now() - new Date(memory.created_at).getTime()) / (1000 * 60 * 60 * 24);
+            const lastUsedDays = ageDays; // Simplified: assume last used = created
+            const shouldPrune = ageDays > maxAgeDays ||
+                memory.confidence < minConfidence ||
+                (memory.usage_count === 0 && lastUsedDays > unusedDays);
+            if (shouldPrune) {
+                this.db.deleteMemory(memory.id);
+                pruned++;
+            }
+        }
+        // Detect contradictions (simplified)
+        const contradictions = 0; // TODO: Implement semantic contradiction detection
+        this.memoriesSinceConsolidation = 0;
+        return {
+            processed: allMemories.length,
+            duplicates: duplicates.length,
+            contradictions,
+            pruned,
+            durationMs: Date.now() - startTime
+        };
+    }
+    /**
+     * High-level task execution with full learning loop
+     */
+    async runTask(options) {
+        // Phase 1: RETRIEVE
+        const memories = await this.retrieve({
+            query: options.query,
+            domain: options.domain
+        });
+        // EXECUTE
+        const result = await options.executeFn(memories);
+        // Phase 2: JUDGE
+        const verdict = await this.judge(result.log);
+        // Phase 3: DISTILL
+        await this.distill(options.taskId, result.log, verdict, options.domain);
+        // Phase 4: CONSOLIDATE (if threshold reached)
+        if (this.memoriesSinceConsolidation >= this.consolidationThreshold) {
+            await this.consolidate();
+        }
+        return {
+            success: result.success,
+            summary: `Task ${options.taskId}: ${verdict.label} (confidence: ${verdict.confidence})`,
+            memories,
+            verdict
+        };
+    }
+    /**
+     * MaTTS: Memory-aware Test-Time Scaling (Parallel)
+     */
+    async mattsParallel(options) {
+        const runs = await Promise.all(Array.from({ length: options.k }, async (_, i) => {
+            const memories = await this.retrieve({
+                query: options.query,
+                domain: options.domain
+            });
+            const result = await options.executeFn(memories);
+            const verdict = await this.judge(result.log);
+            this.db.insertMattsRun({
+                task_id: options.taskId,
+                run_index: i,
+                result: result.log,
+                verdict: verdict.label,
+                confidence: verdict.confidence
+            });
+            return { result, verdict };
+        }));
+        // Calculate consensus
+        const successes = runs.filter(r => r.verdict.label === 'Success').length;
+        const avgConfidence = runs.reduce((sum, r) => sum + r.verdict.confidence, 0) / runs.length;
+        const consensusVerdict = {
+            label: successes > runs.length / 2 ? 'Success' : 'Failure',
+            confidence: avgConfidence
+        };
+        return {
+            success: consensusVerdict.label === 'Success',
+            summary: `MaTTS Parallel: ${successes}/${runs.length} successes, consensus: ${consensusVerdict.label}`,
+            memories: [],
+            verdict: consensusVerdict
+        };
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return this.db.getStats();
+    }
+    /**
+     * Close database connection
+     */
+    close() {
+        this.db.close();
+    }
+}

package/dist/reasoningbank/core/retrieve.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Memory Retrieval with MMR diversity
+ * Algorithm 1 from ReasoningBank paper
+ */
+export interface RetrievedMemory {
+    id: string;
+    title: string;
+    description: string;
+    content: string;
+    score: number;
+    components: {
+        similarity: number;
+        recency: number;
+        reliability: number;
+    };
+}
+/**
+ * Retrieve top-k memories with MMR diversity
+ *
+ * Scoring formula: score = α·sim + β·recency + γ·reliability
+ * Where:
+ * - sim: cosine similarity to query
+ * - recency: exp(-age_days / half_life)
+ * - reliability: min(confidence, 1.0)
+ */
+export declare function retrieveMemories(query: string, options?: {
+    k?: number;
+    domain?: string;
+    agent?: string;
+}): Promise<RetrievedMemory[]>;
+/**
+ * Format memories for injection into system prompt
+ */
+export declare function formatMemoriesForPrompt(memories: RetrievedMemory[]): string;
+//# sourceMappingURL=retrieve.d.ts.map

package/dist/reasoningbank/db/queries.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Database queries for ReasoningBank
+ * Operates on Claude Flow's memory.db at .swarm/memory.db
+ */
+import Database from 'better-sqlite3';
+import type { ReasoningMemory, PatternEmbedding, TaskTrajectory, MattsRun } from './schema.js';
+/**
+ * Run database migrations (create tables)
+ */
+export declare function runMigrations(): Promise<void>;
+/**
+ * Get database connection (singleton)
+ */
+export declare function getDb(): Database.Database;
+/**
+ * Fetch reasoning memory candidates for retrieval
+ */
+export declare function fetchMemoryCandidates(options: {
+    domain?: string;
+    agent?: string;
+    minConfidence?: number;
+}): Array<ReasoningMemory & {
+    embedding: Float32Array;
+    age_days: number;
+}>;
+/**
+ * Store a new reasoning memory
+ */
+export declare function upsertMemory(memory: Omit<ReasoningMemory, 'created_at' | 'last_used'>): string;
+/**
+ * Store embedding for a memory
+ */
+export declare function upsertEmbedding(embedding: PatternEmbedding): void;
+/**
+ * Increment usage count for a memory
+ */
+export declare function incrementUsage(memoryId: string): void;
+/**
+ * Store task trajectory
+ */
+export declare function storeTrajectory(trajectory: Omit<TaskTrajectory, 'created_at'>): void;
+/**
+ * Store MaTTS run
+ */
+export declare function storeMattsRun(run: Omit<MattsRun, 'created_at'>): void;
+/**
+ * Log performance metric
+ */
+export declare function logMetric(name: string, value: number): void;
+/**
+ * Count new memories since last consolidation
+ */
+export declare function countNewMemoriesSinceConsolidation(): number;
+/**
+ * Get all active reasoning memories
+ */
+export declare function getAllActiveMemories(): ReasoningMemory[];
+/**
+ * Store memory link (relationship)
+ */
+export declare function storeLink(srcId: string, dstId: string, relation: 'entails' | 'contradicts' | 'refines' | 'duplicate_of', weight: number): void;
+/**
+ * Get contradictions for a memory
+ */
+export declare function getContradictions(memoryId: string): string[];
+/**
+ * Store consolidation run
+ */
+export declare function storeConsolidationRun(run: {
+    run_id: string;
+    items_processed: number;
+    duplicates_found: number;
+    contradictions_found: number;
+    items_pruned: number;
+    duration_ms: number;
+}): void;
+/**
+ * Prune old, unused memories
+ */
+export declare function pruneOldMemories(options: {
+    maxAgeDays: number;
+    minConfidence: number;
+}): number;
+/**
+ * Close database connection
+ */
+export declare function closeDb(): void;
+//# sourceMappingURL=queries.d.ts.map

package/dist/reasoningbank/db/schema.d.ts

@@ -0,0 +1,81 @@
+/**
+ * TypeScript types for ReasoningBank database schema
+ */
+export interface ReasoningMemory {
+    id: string;
+    type: 'reasoning_memory';
+    pattern_data: {
+        title: string;
+        description: string;
+        content: string;
+        source: {
+            task_id: string;
+            agent_id: string;
+            outcome: 'Success' | 'Failure';
+            evidence: string[];
+        };
+        tags: string[];
+        domain?: string;
+        created_at: string;
+        confidence: number;
+        n_uses: number;
+    };
+    confidence: number;
+    usage_count: number;
+    created_at: string;
+    last_used?: string;
+}
+export interface PatternEmbedding {
+    id: string;
+    model: string;
+    dims: number;
+    vector: Float32Array;
+    created_at: string;
+}
+export interface PatternLink {
+    src_id: string;
+    dst_id: string;
+    relation: 'entails' | 'contradicts' | 'refines' | 'duplicate_of';
+    weight: number;
+    created_at: string;
+}
+export interface TaskTrajectory {
+    task_id: string;
+    agent_id: string;
+    query: string;
+    trajectory_json: string;
+    started_at?: string;
+    ended_at?: string;
+    judge_label?: 'Success' | 'Failure';
+    judge_conf?: number;
+    judge_reasons?: string;
+    matts_run_id?: string;
+    created_at: string;
+}
+export interface MattsRun {
+    run_id: string;
+    task_id: string;
+    mode: 'parallel' | 'sequential';
+    k: number;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    summary?: string;
+    created_at: string;
+}
+export interface ConsolidationRun {
+    run_id: string;
+    items_processed: number;
+    duplicates_found: number;
+    contradictions_found: number;
+    items_pruned: number;
+    duration_ms: number;
+    created_at: string;
+}
+export interface Trajectory {
+    steps: TrajectoryStep[];
+    metadata?: Record<string, any>;
+}
+export interface TrajectoryStep {
+    action: string;
+    [key: string]: any;
+}
+//# sourceMappingURL=schema.d.ts.map

package/dist/reasoningbank/demo-comparison.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * ReasoningBank vs Traditional Approach - Live Demo
+ *
+ * This demo shows the difference between:
+ * 1. Traditional approach: Agent starts fresh every time
+ * 2. ReasoningBank approach: Agent learns from experience
+ */
+export {};
+//# sourceMappingURL=demo-comparison.d.ts.map

package/dist/reasoningbank/hooks/post-task.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * Post-Task Hook for ReasoningBank
+ * Judges trajectory, distills memories, and runs consolidation
+ *
+ * Usage: tsx hooks/post-task.ts --task-id <id> [--trajectory-file <file>]
+ */
+export {};
+//# sourceMappingURL=post-task.d.ts.map

package/dist/reasoningbank/hooks/pre-task.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * Pre-Task Hook for ReasoningBank
+ * Retrieves and injects relevant memories before task execution
+ *
+ * Usage: tsx hooks/pre-task.ts --task-id <id> --query <query> [--domain <domain>] [--agent <agent>]
+ */
+export {};
+//# sourceMappingURL=pre-task.d.ts.map

package/dist/reasoningbank/index-new.d.ts

@@ -0,0 +1,44 @@
+/**
+ * ReasoningBank - Closed-loop memory system for AI agents
+ * Based on arXiv:2509.25140 (Google DeepMind)
+ *
+ * @since v1.7.0 - Integrated AgentDB for optimal performance
+ */
+export { HybridReasoningBank } from './HybridBackend.js';
+export { AdvancedMemorySystem } from './AdvancedMemory.js';
+export type { PatternData, RetrievalOptions, CausalInsight } from './HybridBackend.js';
+export type { FailureAnalysis, SkillComposition } from './AdvancedMemory.js';
+export { ReflexionMemory, SkillLibrary, CausalMemoryGraph, CausalRecall, NightlyLearner, EmbeddingService } from 'agentdb';
+export { retrieveMemories, formatMemoriesForPrompt } from './core/retrieve.js';
+export type { RetrievedMemory } from './core/retrieve.js';
+export { judgeTrajectory } from './core/judge.js';
+export type { Verdict } from './core/judge.js';
+export { distillMemories } from './core/distill.js';
+export type { DistilledMemory } from './core/distill.js';
+export { consolidate, shouldConsolidate } from './core/consolidate.js';
+export type { ConsolidationResult } from './core/consolidate.js';
+export { mattsParallel, mattsSequential } from './core/matts.js';
+export type { MattsResult } from './core/matts.js';
+export { computeEmbedding, clearEmbeddingCache } from './utils/embeddings.js';
+export { mmrSelection, cosineSimilarity } from './utils/mmr.js';
+export { scrubPII, containsPII, scrubMemory } from './utils/pii-scrubber.js';
+export { loadConfig } from './utils/config.js';
+import * as db from './db/queries.js';
+export { db };
+export type { ReasoningMemory, PatternEmbedding, PatternLink, TaskTrajectory, MattsRun, ConsolidationRun, Trajectory, TrajectoryStep } from './db/schema.js';
+export declare function initialize(): Promise<void>;
+export declare function runTask(options: {
+    taskId: string;
+    agentId: string;
+    query: string;
+    domain?: string;
+    executeFn: (memories: any[]) => Promise<any>;
+}): Promise<{
+    verdict: any;
+    usedMemories: any[];
+    newMemories: string[];
+    consolidated: boolean;
+}>;
+export declare const VERSION = "1.7.0";
+export declare const PAPER_URL = "https://arxiv.org/html/2509.25140v1";
+//# sourceMappingURL=index-new.d.ts.map

package/dist/reasoningbank/index-new.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-new.d.ts","sourceRoot":"","sources":["../../src/reasoningbank/index-new.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACvF,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAG7E,OAAO,EACL,eAAe,EACf,YAAY,EACZ,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACd,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAC/E,YAAY,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,YAAY,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACvE,YAAY,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACjE,YAAY,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC9E,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAG/C,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACtC,OAAO,EAAE,EAAE,EAAE,CAAC;AACd,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,QAAQ,EACR,gBAAgB,EAChB,UAAU,EACV,cAAc,EACf,MAAM,gBAAgB,CAAC;AASxB,wBAAsB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CA0BhD;AAED,wBAAsB,OAAO,CAAC,OAAO,EAAE;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CAC9C,GAAG,OAAO,CAAC;IACV,OAAO,EAAE,GAAG,CAAC;IACb,YAAY,EAAE,GAAG,EAAE,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC,CAuBD;AAED,eAAO,MAAM,OAAO,UAAU,CAAC;AAC/B,eAAO,MAAM,SAAS,wCAAwC,CAAC"}