modular-studio 1.0.6 → 1.1.0

package/dist-server/src/graph/scanner.js

@@ -0,0 +1,252 @@
+/**
+ * File Scanner — Builds FileNodes with symbols and content hash
+ *
+ * Incremental: only re-processes files whose contentHash changed.
+ * Orchestrates relation extraction across all file types.
+ */
+import { extractCodeRelations } from './extractors/code.js';
+import { extractMarkdownRelations, extractMarkdownSymbols } from './extractors/markdown.js';
+import { extractYamlRelations } from './extractors/yaml.js';
+import { extractCrossTypeRelations } from './extractors/cross-type.js';
+import { estimateTokens } from '../services/treeIndexer.js';
+// ── Language Detection ────────────────────────────────────────────────────────
+const LANGUAGE_MAP = {
+    ts: 'typescript', tsx: 'typescript', js: 'typescript', jsx: 'typescript',
+    py: 'python',
+    md: 'markdown', mdx: 'markdown',
+    yml: 'yaml', yaml: 'yaml',
+    json: 'json',
+};
+const IGNORE_PATTERNS = [
+    /node_modules\//,
+    /\.git\//,
+    /dist\//,
+    /build\//,
+    /\.next\//,
+    /\.cache\//,
+    /coverage\//,
+    /\.DS_Store/,
+    /package-lock\.json/,
+    /yarn\.lock/,
+    /pnpm-lock\.yaml/,
+];
+export function detectLanguage(filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase() ?? '';
+    return LANGUAGE_MAP[ext] ?? 'unknown';
+}
+export function shouldIndex(filePath) {
+    if (IGNORE_PATTERNS.some(p => p.test(filePath)))
+        return false;
+    const lang = detectLanguage(filePath);
+    return lang !== 'unknown';
+}
+// ── Content Hash ──────────────────────────────────────────────────────────────
+/**
+ * Simple hash for change detection. Uses DJB2 for speed.
+ */
+export function hashContent(content) {
+    let hash = 5381;
+    for (let i = 0; i < content.length; i++) {
+        hash = ((hash << 5) + hash + content.charCodeAt(i)) & 0xffffffff;
+    }
+    return hash.toString(36);
+}
+// ── File ID ───────────────────────────────────────────────────────────────────
+export function fileId(path) {
+    // Deterministic ID from path
+    return hashContent(path);
+}
+// ── Symbol Extraction ─────────────────────────────────────────────────────────
+// Code symbol patterns (simplified from existing codeIndexer)
+const TS_EXPORT_SYM = /^export\s+(?:default\s+)?(?:async\s+)?(?:declare\s+)?(?:(?:abstract\s+)?class|interface|type|enum|function|(?:const|let|var))\s+(\w+)/gm;
+const PY_DEF_SYM = /^(?:class|(?:async\s+)?def)\s+(\w+)/gm;
+function extractCodeSymbols(content, language) {
+    const symbols = [];
+    // const _lines = content.split('\n');
+    if (language === 'typescript') {
+        TS_EXPORT_SYM.lastIndex = 0;
+        let match;
+        while ((match = TS_EXPORT_SYM.exec(content)) !== null) {
+            const lineNum = content.substring(0, match.index).split('\n').length;
+            const name = match[1];
+            const line = match[0];
+            let kind = 'const';
+            if (/class\b/.test(line))
+                kind = 'class';
+            else if (/interface\b/.test(line))
+                kind = 'interface';
+            else if (/type\b/.test(line))
+                kind = 'type';
+            else if (/enum\b/.test(line))
+                kind = 'enum';
+            else if (/function\b/.test(line))
+                kind = 'function';
+            symbols.push({
+                name,
+                kind,
+                lineStart: lineNum,
+                lineEnd: lineNum, // Simplified — would need block end detection
+                isExported: true,
+                tokens: estimateTokens(line),
+            });
+        }
+        // Also find non-exported top-level declarations for internal reference
+        const NON_EXPORT = /^(?:(?:abstract\s+)?class|interface|type|enum|function|(?:const|let|var))\s+(\w+)/gm;
+        NON_EXPORT.lastIndex = 0;
+        while ((match = NON_EXPORT.exec(content)) !== null) {
+            const name = match[1];
+            if (symbols.some(s => s.name === name))
+                continue;
+            const lineNum = content.substring(0, match.index).split('\n').length;
+            symbols.push({
+                name,
+                kind: 'function',
+                lineStart: lineNum,
+                lineEnd: lineNum,
+                isExported: false,
+                tokens: estimateTokens(match[0]),
+            });
+        }
+    }
+    else if (language === 'python') {
+        PY_DEF_SYM.lastIndex = 0;
+        let match;
+        while ((match = PY_DEF_SYM.exec(content)) !== null) {
+            const lineNum = content.substring(0, match.index).split('\n').length;
+            const name = match[1];
+            const isClass = match[0].startsWith('class');
+            symbols.push({
+                name,
+                kind: isClass ? 'class' : 'function',
+                lineStart: lineNum,
+                lineEnd: lineNum,
+                isExported: !name.startsWith('_'),
+                tokens: estimateTokens(match[0]),
+            });
+        }
+    }
+    return symbols;
+}
+// ── Build FileNode ────────────────────────────────────────────────────────────
+export function buildFileNode(path, content, lastModified = Date.now()) {
+    const language = detectLanguage(path);
+    const id = fileId(path);
+    let symbols;
+    if (language === 'markdown') {
+        symbols = extractMarkdownSymbols(content).map(s => ({
+            ...s,
+            tokens: estimateTokens(s.name),
+        }));
+    }
+    else {
+        symbols = extractCodeSymbols(content, language);
+    }
+    return {
+        id,
+        path,
+        language,
+        lastModified,
+        contentHash: hashContent(content),
+        tokens: estimateTokens(content),
+        symbols,
+    };
+}
+// ── Full Scan ─────────────────────────────────────────────────────────────────
+/**
+ * Scan all files from a list of {path, content, mtime} entries.
+ * This is the main entry point — the caller reads the filesystem.
+ */
+export function fullScan(files, db) {
+    const start = Date.now();
+    db.clear();
+    // Phase 1: Build all FileNodes
+    const nodes = [];
+    for (const f of files) {
+        if (!shouldIndex(f.path))
+            continue;
+        const node = buildFileNode(f.path, f.content, f.mtime ?? Date.now());
+        db.upsertNode(node);
+        nodes.push(node);
+    }
+    // Phase 2: Extract relations (needs all nodes indexed first)
+    let totalRelations = 0;
+    const allNodes = db.getAllNodes();
+    const contentMap = new Map(files.map(f => [fileId(f.path), f.content]));
+    for (const node of allNodes) {
+        const content = contentMap.get(node.id) ?? '';
+        let rels = [];
+        if (node.language === 'typescript' || node.language === 'python') {
+            rels = extractCodeRelations(node, allNodes, content);
+        }
+        else if (node.language === 'markdown') {
+            rels = extractMarkdownRelations(node, allNodes, content);
+        }
+        else if (node.language === 'yaml' || node.language === 'json') {
+            rels = extractYamlRelations(node, allNodes, content);
+        }
+        const crossRels = extractCrossTypeRelations(node, allNodes, content);
+        db.addRelations([...rels, ...crossRels]);
+        totalRelations += rels.length + crossRels.length;
+    }
+    const stats = db.getStats();
+    return {
+        totalFiles: stats.nodes,
+        totalSymbols: stats.symbols,
+        totalRelations: stats.relations,
+        filesUpdated: stats.nodes,
+        relationsAdded: totalRelations,
+        relationsRemoved: 0,
+        staleFilesTriggered: 0,
+        durationMs: Date.now() - start,
+    };
+}
+/**
+ * Incremental update: process only changed files.
+ */
+export function updateFiles(changedFiles, db) {
+    const start = Date.now();
+    let filesUpdated = 0;
+    let relationsAdded = 0;
+    let relationsRemoved = 0;
+    let staleFilesTriggered = 0;
+    for (const f of changedFiles) {
+        if (!shouldIndex(f.path))
+            continue;
+        const id = fileId(f.path);
+        const existing = db.getNode(id);
+        const newHash = hashContent(f.content);
+        // Skip if unchanged
+        if (existing && existing.contentHash === newHash)
+            continue;
+        // Remove old relations from this file
+        if (existing) {
+            relationsRemoved += db.removeRelationsForSource(id);
+        }
+        // Rebuild node
+        const node = buildFileNode(f.path, f.content, f.mtime ?? Date.now());
+        db.upsertNode(node);
+        filesUpdated++;
+        // Re-extract relations
+        const allNodes = db.getAllNodes();
+        let rels = [];
+        if (node.language === 'typescript' || node.language === 'python') {
+            rels = extractCodeRelations(node, allNodes, f.content);
+        }
+        else if (node.language === 'markdown') {
+            rels = extractMarkdownRelations(node, allNodes, f.content);
+        }
+        else if (node.language === 'yaml' || node.language === 'json') {
+            rels = extractYamlRelations(node, allNodes, f.content);
+        }
+        const crossRels = extractCrossTypeRelations(node, allNodes, f.content);
+        db.addRelations([...rels, ...crossRels]);
+        relationsAdded += rels.length + crossRels.length;
+    }
+    return {
+        filesUpdated,
+        relationsAdded,
+        relationsRemoved,
+        staleFilesTriggered,
+        durationMs: Date.now() - start,
+    };
+}

package/dist-server/src/graph/traverser.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Graph Traverser — BFS with priority queue
+ *
+ * From entry points, walk the graph collecting files with decaying relevance.
+ * Respects token budget and traversal config (follow imports, callers, etc.)
+ */
+import type { ContextGraph, EntryPoint, TraversalConfig, TraversalResult } from './types.js';
+import { type TaskType } from './types.js';
+/**
+ * Traverse the graph from entry points.
+ */
+export declare function traverseGraph(entryPoints: EntryPoint[], graph: ContextGraph, config?: Partial<TraversalConfig>): TraversalResult;
+/**
+ * Convenience: auto-detect task type and traverse with preset.
+ */
+export declare function traverseForTask(query: string, entryPoints: EntryPoint[], graph: ContextGraph, taskType?: TaskType): TraversalResult;
+//# sourceMappingURL=traverser.d.ts.map

package/dist-server/src/graph/traverser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverser.d.ts","sourceRoot":"","sources":["../../../src/graph/traverser.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,eAAe,EAE3D,MAAM,YAAY,CAAC;AACpB,OAAO,EAAqC,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AA0D9E;;GAEG;AACH,wBAAgB,aAAa,CAC3B,WAAW,EAAE,UAAU,EAAE,EACzB,KAAK,EAAE,YAAY,EACnB,MAAM,GAAE,OAAO,CAAC,eAAe,CAAM,GACpC,eAAe,CAyIjB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,UAAU,EAAE,EACzB,KAAK,EAAE,YAAY,EACnB,QAAQ,CAAC,EAAE,QAAQ,GAClB,eAAe,CAIjB"}

package/dist-server/src/graph/traverser.js

@@ -0,0 +1,185 @@
+/**
+ * Graph Traverser — BFS with priority queue
+ *
+ * From entry points, walk the graph collecting files with decaying relevance.
+ * Respects token budget and traversal config (follow imports, callers, etc.)
+ */
+import { TRAVERSAL_PRESETS, detectTaskType } from './types.js';
+const DECAY_FACTOR = 0.7;
+const DEFAULT_CONFIG = {
+    maxDepth: 3,
+    maxFiles: 20,
+    tokenBudget: 100000,
+    minWeight: 0.3,
+    followImports: true,
+    followCallers: false,
+    followTests: false,
+    followDocs: true,
+    followLinks: true,
+    followReferences: true,
+};
+/**
+ * Check if a relation kind should be followed based on config.
+ */
+function shouldFollowRelation(kind, config) {
+    switch (kind) {
+        case 'imports':
+        case 'extends':
+        case 'implements':
+        case 'uses_type':
+            return config.followImports;
+        case 'calls':
+            return config.followImports; // calls follow same setting as imports
+        case 'tested_by':
+        case 'tests':
+            return config.followTests;
+        case 'documents':
+            return config.followDocs;
+        case 'links_to':
+        case 'continues':
+        case 'supersedes':
+        case 'depends_on':
+        case 'defined_in':
+            return config.followLinks;
+        case 'references':
+            return config.followReferences;
+        case 'configured_by':
+            return config.followImports;
+        case 'related':
+            return config.followReferences;
+        default:
+            return false;
+    }
+}
+/**
+ * Traverse the graph from entry points.
+ */
+export function traverseGraph(entryPoints, graph, config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    const visited = new Map(); // fileId → best item
+    const queue = [];
+    let nodesTraversed = 0;
+    let edgesFollowed = 0;
+    let nodesPruned = 0;
+    // Seed with entry points
+    for (const ep of entryPoints) {
+        const item = {
+            fileId: ep.fileId,
+            relevance: ep.confidence,
+            distance: 0,
+            reason: `Entry point: ${ep.reason}${ep.symbolName ? ` (${ep.symbolName})` : ''}`,
+        };
+        queue.push(item);
+        visited.set(ep.fileId, item);
+    }
+    // BFS with priority (process highest relevance first)
+    while (queue.length > 0) {
+        // Sort by relevance descending (priority queue)
+        queue.sort((a, b) => b.relevance - a.relevance);
+        const current = queue.shift();
+        if (current.distance >= cfg.maxDepth)
+            continue;
+        nodesTraversed++;
+        // Get outgoing relations
+        const outgoing = graph.outgoing.get(current.fileId) ?? [];
+        // Also check incoming for reverse traversal (callers)
+        const incoming = cfg.followCallers
+            ? (graph.incoming.get(current.fileId) ?? [])
+            : [];
+        const allEdges = [];
+        for (const rel of outgoing) {
+            if (shouldFollowRelation(rel.kind, cfg) && rel.weight >= cfg.minWeight) {
+                allEdges.push({
+                    rel,
+                    targetId: rel.targetFile,
+                    reason: `${rel.kind} from ${graph.nodes.get(current.fileId)?.path ?? current.fileId}`,
+                });
+            }
+        }
+        for (const rel of incoming) {
+            // Reverse: incoming relation means this file is TARGET, we follow to SOURCE
+            const reverseKinds = ['calls', 'imports', 'extends', 'implements'];
+            if (reverseKinds.includes(rel.kind) && rel.weight >= cfg.minWeight) {
+                allEdges.push({
+                    rel,
+                    targetId: rel.sourceFile,
+                    reason: `called/imported by ${graph.nodes.get(rel.sourceFile)?.path ?? rel.sourceFile}`,
+                });
+            }
+        }
+        for (const { rel, targetId, reason } of allEdges) {
+            edgesFollowed++;
+            const newRelevance = current.relevance * rel.weight * DECAY_FACTOR;
+            if (newRelevance < cfg.minWeight) {
+                nodesPruned++;
+                continue;
+            }
+            const existing = visited.get(targetId);
+            if (existing && existing.relevance >= newRelevance)
+                continue;
+            const item = {
+                fileId: targetId,
+                relevance: newRelevance,
+                distance: current.distance + 1,
+                reason,
+            };
+            visited.set(targetId, item);
+            queue.push(item);
+        }
+    }
+    // Build result: sort by relevance, cap at maxFiles, respect token budget
+    const allFiles = [];
+    let totalTokens = 0;
+    const sorted = Array.from(visited.values())
+        .sort((a, b) => b.relevance - a.relevance);
+    for (const item of sorted) {
+        if (allFiles.length >= cfg.maxFiles) {
+            nodesPruned++;
+            continue;
+        }
+        const node = graph.nodes.get(item.fileId);
+        if (!node)
+            continue;
+        if (totalTokens + node.tokens > cfg.tokenBudget) {
+            // Still include at reduced depth if possible
+            if (totalTokens + 100 <= cfg.tokenBudget) {
+                allFiles.push({
+                    node,
+                    relevance: item.relevance,
+                    distance: item.distance,
+                    reason: item.reason,
+                });
+                totalTokens += 100; // Approximate headline-only cost
+            }
+            else {
+                nodesPruned++;
+            }
+            continue;
+        }
+        allFiles.push({
+            node,
+            relevance: item.relevance,
+            distance: item.distance,
+            reason: item.reason,
+        });
+        totalTokens += node.tokens;
+    }
+    return {
+        files: allFiles,
+        totalTokens,
+        graphStats: {
+            nodesTraversed,
+            edgesFollowed,
+            nodesIncluded: allFiles.length,
+            nodesPruned,
+        },
+    };
+}
+/**
+ * Convenience: auto-detect task type and traverse with preset.
+ */
+export function traverseForTask(query, entryPoints, graph, taskType) {
+    const task = taskType ?? detectTaskType(query);
+    const preset = TRAVERSAL_PRESETS[task];
+    return traverseGraph(entryPoints, graph, preset);
+}

package/dist-server/src/graph/types.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Context Graph — Type Definitions
+ *
+ * Universal dependency graph for code, markdown, YAML, and JSON files.
+ * Tracks cross-file relations for query-driven context assembly.
+ */
+import type { TreeIndex } from '../services/treeIndexer.js';
+export type FileLanguage = 'typescript' | 'python' | 'markdown' | 'yaml' | 'json' | 'unknown';
+export type SymbolKind = 'function' | 'class' | 'interface' | 'type' | 'const' | 'enum' | 'heading' | 'anchor' | 'definition' | 'link_target' | 'tag' | 'key' | 'schema' | 'export';
+export interface SymbolDef {
+    name: string;
+    kind: SymbolKind;
+    signature?: string;
+    lineStart: number;
+    lineEnd: number;
+    isExported: boolean;
+    treeNodeId?: string;
+    docstring?: string;
+    tokens?: number;
+}
+export interface FileNode {
+    id: string;
+    path: string;
+    language: FileLanguage;
+    lastModified: number;
+    contentHash: string;
+    tokens: number;
+    treeIndex?: TreeIndex;
+    symbols: SymbolDef[];
+}
+export type RelationKind = 'imports' | 'calls' | 'extends' | 'implements' | 'uses_type' | 'tested_by' | 'tests' | 'links_to' | 'references' | 'continues' | 'supersedes' | 'depends_on' | 'defined_in' | 'documents' | 'configured_by' | 'related';
+export interface Relation {
+    id?: number;
+    sourceFile: string;
+    sourceSymbol?: string;
+    targetFile: string;
+    targetSymbol?: string;
+    kind: RelationKind;
+    weight: number;
+    metadata?: Record<string, string>;
+}
+export interface ContextGraph {
+    nodes: Map<string, FileNode>;
+    relations: Relation[];
+    outgoing: Map<string, Relation[]>;
+    incoming: Map<string, Relation[]>;
+    symbolIndex: Map<string, FileNode[]>;
+    rootPath: string;
+    lastFullScan: number;
+    version: number;
+}
+export interface TraversalConfig {
+    maxDepth: number;
+    maxFiles: number;
+    tokenBudget: number;
+    minWeight: number;
+    followImports: boolean;
+    followCallers: boolean;
+    followTests: boolean;
+    followDocs: boolean;
+    followLinks: boolean;
+    followReferences: boolean;
+}
+export interface TraversalResult {
+    files: TraversalFile[];
+    totalTokens: number;
+    graphStats: {
+        nodesTraversed: number;
+        edgesFollowed: number;
+        nodesIncluded: number;
+        nodesPruned: number;
+    };
+}
+export interface TraversalFile {
+    node: FileNode;
+    relevance: number;
+    distance: number;
+    reason: string;
+    includeSymbols?: string[];
+}
+export interface EntryPoint {
+    fileId: string;
+    symbolName?: string;
+    confidence: number;
+    reason: 'Direct mention' | 'Filename match' | 'Semantic match';
+}
+export interface PackedContext {
+    items: PackedItem[];
+    totalTokens: number;
+    budgetUtilization: number;
+}
+export interface PackedItem {
+    file: FileNode;
+    content: string;
+    depth: number;
+    tokens: number;
+    relevance: number;
+}
+export interface UpdateResult {
+    filesUpdated: number;
+    relationsAdded: number;
+    relationsRemoved: number;
+    staleFilesTriggered: number;
+    durationMs: number;
+}
+export interface ScanResult extends UpdateResult {
+    totalFiles: number;
+    totalSymbols: number;
+    totalRelations: number;
+}
+export type TaskType = 'fix' | 'review' | 'explain' | 'build' | 'document' | 'research';
+export declare const TRAVERSAL_PRESETS: Record<TaskType, Partial<TraversalConfig>>;
+/**
+ * Auto-detect task type from query keywords.
+ */
+export declare function detectTaskType(query: string): TaskType;
+//# sourceMappingURL=types.d.ts.map

package/dist-server/src/graph/types.d.ts.map

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

package/dist-server/src/graph/types.js

@@ -0,0 +1,63 @@
+/**
+ * Context Graph — Type Definitions
+ *
+ * Universal dependency graph for code, markdown, YAML, and JSON files.
+ * Tracks cross-file relations for query-driven context assembly.
+ */
+export const TRAVERSAL_PRESETS = {
+    fix: {
+        maxDepth: 3, maxFiles: 15,
+        followImports: true, followCallers: false, followTests: true,
+        followDocs: false, followLinks: false, followReferences: false,
+        minWeight: 0.4,
+    },
+    review: {
+        maxDepth: 2, maxFiles: 25,
+        followImports: true, followCallers: true, followTests: true,
+        followDocs: true, followLinks: true, followReferences: false,
+        minWeight: 0.3,
+    },
+    explain: {
+        maxDepth: 4, maxFiles: 20,
+        followImports: true, followCallers: false, followTests: false,
+        followDocs: true, followLinks: true, followReferences: true,
+        minWeight: 0.3,
+    },
+    build: {
+        maxDepth: 2, maxFiles: 15,
+        followImports: true, followCallers: false, followTests: false,
+        followDocs: true, followLinks: false, followReferences: false,
+        minWeight: 0.5,
+    },
+    document: {
+        maxDepth: 3, maxFiles: 20,
+        followImports: true, followCallers: true, followTests: true,
+        followDocs: true, followLinks: true, followReferences: true,
+        minWeight: 0.3,
+    },
+    research: {
+        maxDepth: 4, maxFiles: 30,
+        followImports: false, followCallers: false, followTests: false,
+        followDocs: true, followLinks: true, followReferences: true,
+        minWeight: 0.2,
+    },
+};
+/**
+ * Auto-detect task type from query keywords.
+ */
+export function detectTaskType(query) {
+    const q = query.toLowerCase();
+    if (/fix|bug|error|crash|broken|issue/.test(q))
+        return 'fix';
+    if (/\bresearch\b|find|look.*up|what.*about/.test(q))
+        return 'research';
+    if (/\breview\b|pr\b|pull request|diff|changes/.test(q))
+        return 'review';
+    if (/explain|how does|what is|understand|walk.*through/.test(q))
+        return 'explain';
+    if (/add|build|create|implement|feature|new/.test(q))
+        return 'build';
+    if (/document|readme|write.*doc|api.*doc/.test(q))
+        return 'document';
+    return 'explain';
+}

package/dist-server/src/metaprompt/v2/assembler.d.ts

@@ -0,0 +1,3 @@
+import type { LLMCallConfig, ParsedInput, ResearchResult, PatternSelection, ContextStrategy, AssembledAgent } from './types.js';
+export declare function runAssembler(parsed: ParsedInput, research: ResearchResult, pattern: PatternSelection, context: ContextStrategy, llmConfig: LLMCallConfig): Promise<AssembledAgent>;
+//# sourceMappingURL=assembler.d.ts.map

package/dist-server/src/metaprompt/v2/assembler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assembler.d.ts","sourceRoot":"","sources":["../../../../src/metaprompt/v2/assembler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,cAAc,EAKf,MAAM,YAAY,CAAC;AAuGpB,wBAAsB,YAAY,CAChC,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,cAAc,EACxB,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,eAAe,EACxB,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,cAAc,CAAC,CA4DzB"}