@grafema/core 0.1.0-alpha.1

package/dist/Orchestrator.js

@@ -0,0 +1,481 @@
+/**
+ * Orchestrator - управляет процессом анализа через фазы
+ * Полностью абстрактный - специфичная логика в плагинах
+ */
+import { existsSync, unlinkSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { spawn, execSync } from 'child_process';
+import { setTimeout as sleep } from 'timers/promises';
+import { SimpleProjectDiscovery } from './plugins/discovery/SimpleProjectDiscovery.js';
+import { Profiler } from './core/Profiler.js';
+import { AnalysisQueue } from './core/AnalysisQueue.js';
+export class Orchestrator {
+    graph;
+    config;
+    plugins;
+    workerCount;
+    onProgress;
+    forceAnalysis;
+    serviceFilter;
+    indexOnly;
+    profiler;
+    parallelConfig;
+    analysisQueue;
+    rfdbServerProcess;
+    _serverWasExternal;
+    constructor(options = {}) {
+        this.graph = options.graph;
+        this.config = options;
+        this.plugins = options.plugins || [];
+        this.workerCount = options.workerCount || 10; // ГОРИЗОНТАЛЬНОЕ МАСШТАБИРОВАНИЕ
+        this.onProgress = options.onProgress || (() => { }); // Callback для прогресса
+        this.forceAnalysis = options.forceAnalysis || false; // Флаг для игнорирования кэша
+        this.serviceFilter = options.serviceFilter || null; // Фильтр для одного сервиса
+        this.indexOnly = options.indexOnly || false; // Только DISCOVERY + INDEXING (для coverage)
+        this.profiler = new Profiler('Orchestrator');
+        // Parallel/queue-based analysis config
+        this.parallelConfig = options.parallel || null;
+        this.analysisQueue = null;
+        this.rfdbServerProcess = null;
+        this._serverWasExternal = false;
+        // Auto-add default discovery if no discovery plugins provided
+        const hasDiscovery = this.plugins.some(p => p.metadata?.phase === 'DISCOVERY');
+        if (!hasDiscovery) {
+            this.plugins.unshift(new SimpleProjectDiscovery());
+        }
+    }
+    /**
+     * Запустить анализ проекта
+     */
+    async run(projectPath) {
+        const totalStartTime = Date.now();
+        // Resolve to absolute path
+        const absoluteProjectPath = projectPath.startsWith('/') ? projectPath : resolve(projectPath);
+        this.onProgress({ phase: 'discovery', currentPlugin: 'Starting discovery...', message: 'Discovering services...', totalFiles: 0, processedFiles: 0 });
+        // PHASE 0: DISCOVERY - запуск плагинов фазы DISCOVERY
+        this.profiler.start('DISCOVERY');
+        const manifest = await this.discover(absoluteProjectPath);
+        this.profiler.end('DISCOVERY');
+        const epCount = manifest.entrypoints?.length || 0;
+        const svcCount = manifest.services?.length || 0;
+        this.onProgress({
+            phase: 'discovery',
+            currentPlugin: 'Discovery complete',
+            message: `Found ${svcCount} service(s), ${epCount} entrypoint(s)`,
+            totalFiles: 0,
+            processedFiles: 0
+        });
+        console.log(`[Orchestrator] Discovery: ${svcCount} services, ${epCount} entrypoints`);
+        // Build unified list of indexing units from services AND entrypoints
+        const indexingUnits = this.buildIndexingUnits(manifest);
+        // Filter if specified
+        let unitsToProcess;
+        if (this.serviceFilter) {
+            unitsToProcess = indexingUnits.filter(u => u.name === this.serviceFilter ||
+                u.path === this.serviceFilter ||
+                u.name.includes(this.serviceFilter) ||
+                u.path.includes(this.serviceFilter));
+            console.log(`[Orchestrator] Filtering: ${this.serviceFilter} (found ${unitsToProcess.length} of ${indexingUnits.length})`);
+        }
+        else {
+            unitsToProcess = indexingUnits;
+        }
+        console.log(`[Orchestrator] Processing ${unitsToProcess.length} indexing units (services + entrypoints)`);
+        console.log(`[Orchestrator] Strategy: Phase-by-phase with DFS dependency tree per entrypoint`);
+        // PHASE 1: INDEXING - каждый сервис строит своё дерево зависимостей от entrypoint
+        const indexingStart = Date.now();
+        this.profiler.start('INDEXING');
+        this.onProgress({
+            phase: 'indexing',
+            currentPlugin: 'Starting indexing...',
+            message: 'Building dependency trees...',
+            totalFiles: unitsToProcess.length,
+            processedFiles: 0
+        });
+        // Параллельная обработка units батчами
+        const BATCH_SIZE = this.workerCount;
+        let processedUnits = 0;
+        for (let batchStart = 0; batchStart < unitsToProcess.length; batchStart += BATCH_SIZE) {
+            const batch = unitsToProcess.slice(batchStart, batchStart + BATCH_SIZE);
+            this.onProgress({
+                phase: 'indexing',
+                currentPlugin: 'JSModuleIndexer',
+                message: `[${processedUnits + 1}-${processedUnits + batch.length}/${unitsToProcess.length}] Batch indexing...`,
+                totalFiles: unitsToProcess.length,
+                processedFiles: processedUnits
+            });
+            // Параллельно обрабатываем батч units
+            await Promise.all(batch.map(async (unit, idx) => {
+                const unitStart = Date.now();
+                const unitManifest = {
+                    projectPath: manifest.projectPath,
+                    service: {
+                        ...unit, // Pass all unit fields
+                        id: unit.id,
+                        name: unit.name,
+                        path: unit.path
+                    },
+                    modules: []
+                };
+                await this.runPhase('INDEXING', { manifest: unitManifest, graph: this.graph, workerCount: 1 });
+                const unitTime = ((Date.now() - unitStart) / 1000).toFixed(2);
+                console.log(`[Orchestrator] ⏱️ INDEXING ${unit.name}: ${unitTime}s`);
+                this.onProgress({
+                    phase: 'indexing',
+                    currentPlugin: 'JSModuleIndexer',
+                    message: `Indexed ${unit.name || unit.path} (${unitTime}s)`,
+                    totalFiles: unitsToProcess.length,
+                    processedFiles: processedUnits + idx + 1,
+                    servicesAnalyzed: processedUnits + idx + 1
+                });
+            }));
+            processedUnits += batch.length;
+        }
+        this.profiler.end('INDEXING');
+        console.log(`[Orchestrator] ⏱️ INDEXING phase total: ${((Date.now() - indexingStart) / 1000).toFixed(2)}s`);
+        // Skip remaining phases if indexOnly mode (for coverage)
+        if (this.indexOnly) {
+            const totalTime = ((Date.now() - totalStartTime) / 1000).toFixed(2);
+            console.log(`[Orchestrator] ⏱️ indexOnly mode - skipping ANALYSIS/ENRICHMENT/VALIDATION`);
+            console.log(`[Orchestrator] ⏱️ Total time: ${totalTime}s for ${unitsToProcess.length} units`);
+            return manifest;
+        }
+        // PHASE 2: ANALYSIS - все units (параллельно батчами)
+        const analysisStart = Date.now();
+        this.profiler.start('ANALYSIS');
+        this.onProgress({
+            phase: 'analysis',
+            currentPlugin: 'Starting analysis...',
+            message: 'Analyzing all units...',
+            totalFiles: unitsToProcess.length,
+            processedFiles: 0
+        });
+        // Check if parallel analysis is enabled (new functionality under flag)
+        if (this.parallelConfig?.enabled) {
+            await this.runParallelAnalysis(manifest);
+        }
+        else {
+            // BACKWARD COMPATIBLE: per-unit batch processing (как в JS baseline)
+            processedUnits = 0;
+            for (let batchStart = 0; batchStart < unitsToProcess.length; batchStart += BATCH_SIZE) {
+                const batch = unitsToProcess.slice(batchStart, batchStart + BATCH_SIZE);
+                this.onProgress({
+                    phase: 'analysis',
+                    currentPlugin: 'Analyzers',
+                    message: `[${processedUnits + 1}-${processedUnits + batch.length}/${unitsToProcess.length}] Batch analyzing...`,
+                    totalFiles: unitsToProcess.length,
+                    processedFiles: processedUnits
+                });
+                // Параллельно анализируем батч units
+                await Promise.all(batch.map(async (unit, idx) => {
+                    const unitStart = Date.now();
+                    const unitManifest = {
+                        projectPath: manifest.projectPath,
+                        service: {
+                            ...unit,
+                            id: unit.id,
+                            name: unit.name,
+                            path: unit.path
+                        },
+                        modules: []
+                    };
+                    await this.runPhase('ANALYSIS', { manifest: unitManifest, graph: this.graph, workerCount: 1 });
+                    const unitTime = ((Date.now() - unitStart) / 1000).toFixed(2);
+                    console.log(`[Orchestrator] ⏱️ ANALYSIS ${unit.name}: ${unitTime}s`);
+                    this.onProgress({
+                        phase: 'analysis',
+                        currentPlugin: 'Analyzers',
+                        message: `Analyzed ${unit.name || unit.path} (${unitTime}s)`,
+                        totalFiles: unitsToProcess.length,
+                        processedFiles: processedUnits + idx + 1,
+                        servicesAnalyzed: processedUnits + idx + 1
+                    });
+                }));
+                processedUnits += batch.length;
+            }
+        }
+        this.profiler.end('ANALYSIS');
+        console.log(`[Orchestrator] ⏱️ ANALYSIS phase total: ${((Date.now() - analysisStart) / 1000).toFixed(2)}s`);
+        // PHASE 3: ENRICHMENT - post-processing, граф traversal, вычисления (глобально)
+        const enrichmentStart = Date.now();
+        this.profiler.start('ENRICHMENT');
+        this.onProgress({ phase: 'enrichment', currentPlugin: 'Starting enrichment...', message: 'Enriching graph data...', totalFiles: 0, processedFiles: 0 });
+        await this.runPhase('ENRICHMENT', { manifest, graph: this.graph, workerCount: this.workerCount });
+        this.profiler.end('ENRICHMENT');
+        console.log(`[Orchestrator] ⏱️ ENRICHMENT phase: ${((Date.now() - enrichmentStart) / 1000).toFixed(2)}s`);
+        // PHASE 4: VALIDATION - проверка корректности графа (глобально)
+        const validationStart = Date.now();
+        this.profiler.start('VALIDATION');
+        this.onProgress({ phase: 'validation', currentPlugin: 'Starting validation...', message: 'Validating graph structure...', totalFiles: 0, processedFiles: 0 });
+        await this.runPhase('VALIDATION', { manifest, graph: this.graph, workerCount: this.workerCount });
+        this.profiler.end('VALIDATION');
+        console.log(`[Orchestrator] ⏱️ VALIDATION phase: ${((Date.now() - validationStart) / 1000).toFixed(2)}s`);
+        // Flush graph to ensure all edges are persisted and queryable
+        if (this.graph.flush) {
+            await this.graph.flush();
+        }
+        const totalTime = ((Date.now() - totalStartTime) / 1000).toFixed(2);
+        console.log(`[Orchestrator] ⏱️ Total time: ${totalTime}s for ${unitsToProcess.length} units`);
+        // Print profiling summary
+        this.profiler.printSummary();
+        return manifest;
+    }
+    /**
+     * Build unified list of indexing units from services and entrypoints
+     * Each unit has: id, name, path, type, and original data
+     */
+    buildIndexingUnits(manifest) {
+        const units = [];
+        const seenPaths = new Set();
+        // 1. Add services first (they have priority)
+        for (const service of manifest.services || []) {
+            const path = service.path || service.metadata?.entrypoint;
+            if (path && !seenPaths.has(path)) {
+                seenPaths.add(path);
+                units.push({
+                    ...service, // Spread first to allow overrides
+                    id: service.id,
+                    name: service.name,
+                    path: path,
+                    type: 'service',
+                });
+            }
+        }
+        // 2. Add entrypoints that aren't already covered by services
+        for (const ep of manifest.entrypoints || []) {
+            const path = ep.file;
+            if (path && !seenPaths.has(path)) {
+                seenPaths.add(path);
+                units.push({
+                    ...ep, // Spread first to allow overrides
+                    id: ep.id,
+                    name: ep.name || ep.file.split('/').pop(),
+                    path: path,
+                    type: 'entrypoint',
+                    entrypointType: ep.type,
+                    trigger: ep.trigger,
+                });
+            }
+        }
+        console.log(`[Orchestrator] Built ${units.length} indexing units (${units.filter(u => u.type === 'service').length} services, ${units.filter(u => u.type === 'entrypoint').length} standalone entrypoints)`);
+        return units;
+    }
+    /**
+     * PHASE 0: Discovery - запуск плагинов DISCOVERY фазы
+     */
+    async discover(projectPath) {
+        const context = {
+            projectPath,
+            graph: this.graph,
+            config: this.config,
+            phase: 'DISCOVERY'
+        };
+        // Фильтруем плагины для фазы DISCOVERY
+        const discoveryPlugins = this.plugins.filter(p => p.metadata.phase === 'DISCOVERY');
+        // Сортируем по приоритету
+        discoveryPlugins.sort((a, b) => (b.metadata.priority || 0) - (a.metadata.priority || 0));
+        const allServices = [];
+        const allEntrypoints = [];
+        // Выполняем каждый плагин
+        for (let i = 0; i < discoveryPlugins.length; i++) {
+            const plugin = discoveryPlugins[i];
+            this.onProgress({
+                phase: 'discovery',
+                currentPlugin: plugin.metadata.name,
+                message: `Running ${plugin.metadata.name}... (${i + 1}/${discoveryPlugins.length})`
+            });
+            const result = await plugin.execute(context);
+            if (result.success && result.metadata?.services) {
+                allServices.push(...result.metadata.services);
+            }
+            // Collect entrypoints from new-style plugins
+            if (result.success && result.metadata?.entrypoints) {
+                allEntrypoints.push(...result.metadata.entrypoints);
+            }
+            this.onProgress({
+                phase: 'discovery',
+                currentPlugin: plugin.metadata.name,
+                message: `✓ ${plugin.metadata.name} complete`
+            });
+        }
+        return {
+            services: allServices,
+            entrypoints: allEntrypoints,
+            projectPath: projectPath
+        };
+    }
+    /**
+     * Запустить плагины для конкретной фазы
+     */
+    async runPhase(phaseName, context) {
+        // Фильтруем плагины для данной фазы
+        const phasePlugins = this.plugins.filter(plugin => plugin.metadata.phase === phaseName);
+        // Сортируем по priority (больше = раньше)
+        phasePlugins.sort((a, b) => (b.metadata.priority || 0) - (a.metadata.priority || 0));
+        // Выполняем плагины последовательно
+        for (let i = 0; i < phasePlugins.length; i++) {
+            const plugin = phasePlugins[i];
+            this.onProgress({
+                phase: phaseName.toLowerCase(),
+                currentPlugin: plugin.metadata.name,
+                message: `Running plugin ${i + 1}/${phasePlugins.length}: ${plugin.metadata.name}`
+            });
+            // Передаем onProgress и forceAnalysis в контекст для плагинов
+            const pluginContext = {
+                ...context,
+                onProgress: this.onProgress,
+                forceAnalysis: this.forceAnalysis
+            };
+            await plugin.execute(pluginContext);
+            // Send completion for this plugin
+            this.onProgress({
+                phase: phaseName.toLowerCase(),
+                currentPlugin: plugin.metadata.name,
+                message: `✓ ${plugin.metadata.name} complete`
+            });
+        }
+    }
+    /**
+     * Run queue-based parallel analysis using worker_threads and RFDB server
+     *
+     * Architecture:
+     * - Tasks are queued per-file with list of applicable plugins
+     * - Workers pick tasks, run plugins, write directly to RFDB
+     * - Barrier waits for all tasks before ENRICHMENT phase
+     */
+    async runParallelAnalysis(manifest) {
+        const socketPath = this.parallelConfig.socketPath || '/tmp/rfdb.sock';
+        const maxWorkers = this.parallelConfig.maxWorkers || null;
+        // Get the database path from the main graph backend
+        const mainDbPath = this.graph.dbPath || join(manifest.projectPath, '.grafema', 'graph.rfdb');
+        console.log(`[Orchestrator] Starting queue-based parallel analysis...`);
+        console.log(`[Orchestrator] Using database: ${mainDbPath}`);
+        // Start RFDB server using the SAME database as main graph
+        await this.startRfdbServer(socketPath, mainDbPath);
+        // Get ANALYSIS plugins that should run in workers
+        const analysisPlugins = this.plugins
+            .filter(p => p.metadata?.phase === 'ANALYSIS')
+            .map(p => p.metadata.name);
+        console.log(`[Orchestrator] Analysis plugins: ${analysisPlugins.join(', ')}`);
+        // Create analysis queue
+        this.analysisQueue = new AnalysisQueue({
+            socketPath,
+            maxWorkers: maxWorkers || undefined,
+            plugins: analysisPlugins,
+        });
+        // Start workers
+        await this.analysisQueue.start();
+        // Get all MODULE nodes from graph and queue them
+        let moduleCount = 0;
+        for await (const node of this.graph.queryNodes({ type: 'MODULE' })) {
+            // Skip non-JS/TS files
+            if (!node.file?.match(/\.(js|jsx|ts|tsx|mjs|cjs)$/))
+                continue;
+            this.analysisQueue.addTask({
+                file: node.file,
+                moduleId: node.id,
+                moduleName: node.name,
+                plugins: analysisPlugins, // All plugins for now; workers filter by imports
+            });
+            moduleCount++;
+        }
+        console.log(`[Orchestrator] Queued ${moduleCount} modules for analysis...`);
+        // Subscribe to progress events
+        this.analysisQueue.on('taskCompleted', ({ file, stats, duration }) => {
+            this.onProgress({
+                phase: 'analysis',
+                currentPlugin: 'AnalysisQueue',
+                message: `${file.split('/').pop()} (${stats?.nodes || 0} nodes, ${duration}ms)`,
+            });
+        });
+        this.analysisQueue.on('taskFailed', ({ file, error }) => {
+            console.error(`[Orchestrator] Analysis failed for ${file}: ${error}`);
+        });
+        // Wait for all tasks to complete (barrier)
+        const stats = await this.analysisQueue.waitForCompletion();
+        console.log(`[Orchestrator] Queue complete: ${stats.nodesCreated} nodes, ${stats.edgesCreated} edges`);
+        console.log(`[Orchestrator] ${stats.tasksCompleted} succeeded, ${stats.tasksFailed} failed`);
+        // Stop workers and server
+        await this.analysisQueue.stop();
+        this.analysisQueue = null;
+        await this.stopRfdbServer();
+    }
+    /**
+     * Start RFDB server process (or connect to existing one)
+     * @param socketPath - Unix socket path for the server
+     * @param dbPath - Database path (should be same as main graph)
+     */
+    async startRfdbServer(socketPath, dbPath) {
+        // Check if server is already running (socket exists and is connectable)
+        if (existsSync(socketPath)) {
+            // Try to connect to existing server
+            try {
+                const { RFDBClient } = await import('@grafema/rfdb-client');
+                const testClient = new RFDBClient(socketPath);
+                await testClient.connect();
+                await testClient.ping();
+                await testClient.close();
+                console.log(`[Orchestrator] Using existing RFDB server at ${socketPath}`);
+                this.rfdbServerProcess = null; // Mark that we didn't start the server
+                this._serverWasExternal = true;
+                return;
+            }
+            catch (e) {
+                // Socket exists but server not responding, remove stale socket
+                console.log(`[Orchestrator] Stale socket found, removing...`);
+                unlinkSync(socketPath);
+            }
+        }
+        // Check if server binary exists
+        const projectRoot = join(dirname(fileURLToPath(import.meta.url)), '../..');
+        const serverBinary = join(projectRoot, 'rust-engine/target/release/rfdb-server');
+        const debugBinary = join(projectRoot, 'rust-engine/target/debug/rfdb-server');
+        let binaryPath = existsSync(serverBinary) ? serverBinary : debugBinary;
+        if (!existsSync(binaryPath)) {
+            console.log(`[Orchestrator] RFDB server binary not found at ${binaryPath}, building...`);
+            execSync('cargo build --bin rfdb-server', {
+                cwd: join(projectRoot, 'rust-engine'),
+                stdio: 'inherit',
+            });
+            binaryPath = debugBinary;
+        }
+        console.log(`[Orchestrator] Starting RFDB server: ${binaryPath} with db: ${dbPath}`);
+        this.rfdbServerProcess = spawn(binaryPath, [dbPath, '--socket', socketPath], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        this._serverWasExternal = false;
+        this.rfdbServerProcess.stderr?.on('data', (data) => {
+            const msg = data.toString().trim();
+            if (!msg.includes('FLUSH') && !msg.includes('WRITER')) {
+                console.log(`[rfdb-server] ${msg}`);
+            }
+        });
+        // Wait for server to start
+        let attempts = 0;
+        while (!existsSync(socketPath) && attempts < 30) {
+            await sleep(100);
+            attempts++;
+        }
+        if (!existsSync(socketPath)) {
+            throw new Error('RFDB server failed to start');
+        }
+        console.log(`[Orchestrator] RFDB server started on ${socketPath}`);
+    }
+    /**
+     * Stop RFDB server process (only if we started it)
+     */
+    async stopRfdbServer() {
+        // Don't stop external server (started by MCP or another process)
+        if (this._serverWasExternal) {
+            console.log(`[Orchestrator] Leaving external RFDB server running`);
+            return;
+        }
+        if (this.rfdbServerProcess) {
+            this.rfdbServerProcess.kill('SIGTERM');
+            await sleep(200);
+            this.rfdbServerProcess = null;
+            console.log(`[Orchestrator] RFDB server stopped`);
+        }
+    }
+}

package/dist/api/GraphAPI.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Clean Graph API for visualization
+ * Reads everything directly from RFDB (no caches)
+ */
+import { IncomingMessage, ServerResponse } from 'http';
+/**
+ * Native node from engine
+ */
+interface NativeNode {
+    id: bigint;
+    kind: number;
+    exported: boolean;
+    version: number;
+    name_offset?: number;
+}
+/**
+ * Native edge from engine
+ */
+interface NativeEdge {
+    src: bigint;
+    dst: bigint;
+    etype: number;
+    version: number;
+}
+/**
+ * Engine interface
+ */
+interface GraphEngine {
+    findByType(type: number): bigint[];
+    getNode(id: bigint): NativeNode | null;
+    nodeExists(id: bigint): boolean;
+    getOutgoingEdges(id: bigint, types: number[] | null): NativeEdge[];
+}
+/**
+ * Backend interface
+ */
+interface GraphBackend {
+    engine: GraphEngine;
+    _bigIntToId(id: bigint): string;
+    _idToBigInt(id: string): bigint;
+    _numberToNodeType(kind: number): string;
+    _numberToEdgeType(etype: number): string;
+}
+export declare class GraphAPI {
+    private backend;
+    private port;
+    private server;
+    constructor(backend: GraphBackend, port?: number);
+    /**
+     * Start API server
+     */
+    start(): this;
+    /**
+     * Stop server
+     */
+    stop(): void;
+    /**
+     * Handle HTTP request
+     */
+    handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void>;
+    /**
+     * GET /api/services
+     * Returns all SERVICE nodes
+     */
+    handleGetServices(req: IncomingMessage, res: ServerResponse): Promise<void>;
+    /**
+     * GET /api/node/:id
+     * Returns single node by ID
+     */
+    handleGetNode(req: IncomingMessage, res: ServerResponse, nodeId: string): Promise<void>;
+    /**
+     * GET /api/node/:id/children
+     * Returns children via CONTAINS edges
+     */
+    handleGetChildren(req: IncomingMessage, res: ServerResponse, nodeId: string): Promise<void>;
+    /**
+     * GET /api/node/:id/edges
+     * Returns all outgoing edges from node
+     */
+    handleGetEdges(req: IncomingMessage, res: ServerResponse, nodeId: string): Promise<void>;
+    /**
+     * Get node name from name_offset (TODO: implement string table lookup)
+     */
+    private getNodeName;
+}
+export {};
+//# sourceMappingURL=GraphAPI.d.ts.map

package/dist/api/GraphAPI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphAPI.d.ts","sourceRoot":"","sources":["../../src/api/GraphAPI.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAwB,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAmB7E;;GAEG;AACH,UAAU,UAAU;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,UAAU,UAAU;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,UAAU,WAAW;IACnB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACnC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC;IACvC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,gBAAgB,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,UAAU,EAAE,CAAC;CACpE;AAED;;GAEG;AACH,UAAU,YAAY;IACpB,MAAM,EAAE,WAAW,CAAC;IACpB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IACxC,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1C;AAuBD,qBAAa,QAAQ;IACnB,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,MAAM,CAAgB;gBAElB,OAAO,EAAE,YAAY,EAAE,IAAI,GAAE,MAAa;IAMtD;;OAEG;IACH,KAAK,IAAI,IAAI;IAmBb;;OAEG;IACH,IAAI,IAAI,IAAI;IAOZ;;OAEG;IACG,aAAa,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IA6C7E;;;OAGG;IACG,iBAAiB,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBjF;;;OAGG;IACG,aAAa,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmB7F;;;OAGG;IACG,iBAAiB,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkCjG;;;OAGG;IACG,cAAc,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4B9F;;OAEG;IACH,OAAO,CAAC,WAAW;CAKpB"}