@grafema/core 0.1.0-alpha.1

package/dist/plugins/discovery/ZonServiceDiscovery.js

@@ -0,0 +1,204 @@
+/**
+ * ZonServiceDiscovery - плагин для поиска сервисов в zon1 монорепозитории
+ *
+ * Точная реализация логики из file2host.js:
+ * 1. Читает servers.js - база данных серверов
+ * 2. Использует zserver_conf.prepare_conf() для получения конфигурации каждого сервера
+ * 3. Читает k8s/deploy/configs/apps.json - kubernetes приложения
+ * 4. Извлекает entrypoint'ы для каждого сервиса
+ */
+import { DiscoveryPlugin } from './DiscoveryPlugin.js';
+import { createSuccessResult, createErrorResult } from '../Plugin.js';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { createRequire } from 'module';
+export class ZonServiceDiscovery extends DiscoveryPlugin {
+    constructor(config = {}) {
+        super(config);
+    }
+    // Debug: show which file was loaded at runtime
+    static __loaded = (() => {
+        try {
+            console.log('[ZonServiceDiscovery] module loaded from', import.meta.url);
+        }
+        catch {
+            // Ignore
+        }
+        return true;
+    })();
+    get metadata() {
+        return {
+            name: 'ZonServiceDiscovery',
+            phase: 'DISCOVERY',
+            priority: 100,
+            creates: {
+                nodes: ['SERVICE'],
+                edges: []
+            },
+            dependencies: []
+        };
+    }
+    hostname_base(hostname) {
+        return hostname.replace(/(-ec2)?\d*$/, '$1');
+    }
+    async execute(context) {
+        const { projectPath, graph } = context;
+        console.log(`[ZonServiceDiscovery] Scanning ${projectPath}`);
+        try {
+            // Set environment variable to avoid BUILD error
+            process.env.ZON_CONFIG_FALLBACK = '1';
+            const services = [];
+            const require = createRequire(import.meta.url);
+            // Paths
+            const serversDbPath = join(projectPath, 'pkg/system/db/servers.js');
+            const zserverConfPath = join(projectPath, 'pkg/system/agent/zserver_conf.js');
+            const appsJsonPath = join(projectPath, 'pkg/k8s/deploy/configs/apps.json');
+            // Check if this is zon1 repository
+            if (!existsSync(serversDbPath)) {
+                console.log(`[ZonServiceDiscovery] servers.js not found - not a zon1 repository`);
+                return createErrorResult(new Error(`Not a zon1 repository - servers.js not found`));
+            }
+            console.log(`[ZonServiceDiscovery] Loading servers.js...`);
+            // Load modules
+            let servers_js;
+            let zserver_conf;
+            let k8s_apps = {};
+            try {
+                // Clear require cache to get fresh modules
+                delete require.cache[require.resolve(serversDbPath)];
+                delete require.cache[require.resolve(zserverConfPath)];
+                servers_js = require(serversDbPath);
+                console.log(`[ZonServiceDiscovery] Loaded servers.js`);
+            }
+            catch (err) {
+                console.log(`[ZonServiceDiscovery] Failed to load servers.js:`, err.message);
+                return createErrorResult(err);
+            }
+            try {
+                zserver_conf = require(zserverConfPath);
+                console.log(`[ZonServiceDiscovery] Loaded zserver_conf.js`);
+            }
+            catch (err) {
+                console.log(`[ZonServiceDiscovery] Failed to load zserver_conf.js:`, err.message);
+                return createErrorResult(err);
+            }
+            // Load k8s apps (optional)
+            if (existsSync(appsJsonPath)) {
+                try {
+                    const appsContent = readFileSync(appsJsonPath, 'utf-8');
+                    k8s_apps = JSON.parse(appsContent);
+                    console.log(`[ZonServiceDiscovery] Loaded k8s apps.json`);
+                }
+                catch (err) {
+                    console.log(`[ZonServiceDiscovery] Warning: Failed to load apps.json:`, err.message);
+                }
+            }
+            // Build service tree - exact logic from file2host.js
+            const allServers = Object.entries(servers_js.servers);
+            // Note: file2host uses v.file2host filter, but we'll use entrypoint presence
+            const k8sEntries = Object.entries(k8s_apps).filter(([, v]) => v.entrypoint);
+            console.log(`[ZonServiceDiscovery] Processing ${allServers.length} servers and ${k8sEntries.length} k8s apps...`);
+            const processedGroups = new Set();
+            const serviceMap = new Map(); // entrypoint -> {hosts: [...]}
+            // Process traditional servers - exact logic from file2host.js
+            for (const [hostname, serverConfig] of allServers) {
+                const is_zagent = servers_js.lib.re.zagent.test(hostname);
+                // Skip LPM zagents (util files are transcoded during build)
+                if (is_zagent && serverConfig.type === 'lpm') {
+                    continue;
+                }
+                const hostGroup = is_zagent
+                    ? `${serverConfig.type} zagents`
+                    : this.hostname_base(hostname);
+                if (processedGroups.has(hostGroup)) {
+                    continue;
+                }
+                processedGroups.add(hostGroup);
+                try {
+                    // Get configuration - exact call from file2host.js
+                    const conf = zserver_conf.prepare_conf(hostname)
+                        .filter(c => (c.conf || c.init) && c.file)
+                        .map(({ init, file }) => {
+                        if (!init) {
+                            return file.split('.conf')[0];
+                        }
+                        return init.upstart.xvfs.split(' ')[0];
+                    });
+                    for (const service of conf) {
+                        if (!serviceMap.has(service)) {
+                            serviceMap.set(service, { hosts: [] });
+                        }
+                        serviceMap.get(service).hosts.push({
+                            hostGroup,
+                            hostname,
+                            type: 'traditional'
+                        });
+                    }
+                }
+                catch (err) {
+                    console.log(`[ZonServiceDiscovery] Error processing ${hostname}:`, err.message);
+                }
+            }
+            // Process k8s applications - exact logic from file2host.js
+            for (const [name, config] of k8sEntries) {
+                if (config.entrypoint) {
+                    const entrypoint = config.entrypoint.replace('pkg/', '');
+                    if (!serviceMap.has(entrypoint)) {
+                        serviceMap.set(entrypoint, { hosts: [] });
+                    }
+                    serviceMap.get(entrypoint).hosts.push({
+                        hostGroup: name,
+                        hostname: name,
+                        type: 'k8s'
+                    });
+                }
+            }
+            console.log(`[ZonServiceDiscovery] Found ${serviceMap.size} unique services`);
+            // Show first 20 services as preview
+            const serviceList = Array.from(serviceMap.keys()).sort();
+            console.log(`[ZonServiceDiscovery] Services (showing first 20 of ${serviceList.length}):`);
+            serviceList.slice(0, 20).forEach(s => {
+                const hosts = serviceMap.get(s).hosts;
+                console.log(`  - ${s} (${hosts.length} host${hosts.length > 1 ? 's' : ''})`);
+            });
+            if (serviceList.length > 20) {
+                console.log(`  ... and ${serviceList.length - 20} more`);
+            }
+            // Create SERVICE nodes
+            for (const [entrypoint, data] of serviceMap) {
+                // Use format matching VersionManager.generateStableId()
+                const serviceId = `SERVICE:${entrypoint}`;
+                const servicePath = join(projectPath, 'pkg', entrypoint);
+                // Cast through unknown since we're creating a dynamic service node
+                const metadata = {
+                    discoveryMethod: 'zon',
+                    entrypoint,
+                    hosts: data.hosts,
+                    hostCount: data.hosts.length
+                };
+                const serviceNode = {
+                    id: serviceId,
+                    type: 'SERVICE',
+                    name: entrypoint,
+                    path: servicePath,
+                    metadata
+                };
+                await graph.addNode(serviceNode);
+                services.push({
+                    id: serviceId,
+                    name: entrypoint,
+                    path: servicePath,
+                    type: 'zon-service',
+                    metadata
+                });
+            }
+            console.log(`[ZonServiceDiscovery] Created ${services.length} SERVICE nodes`);
+            return createSuccessResult({ nodes: services.length, edges: 0 }, { services });
+        }
+        catch (error) {
+            console.error(`[ZonServiceDiscovery] Fatal error:`, error);
+            console.error(error.stack);
+            return createErrorResult(error);
+        }
+    }
+}

package/dist/plugins/enrichment/AliasTracker.d.ts

@@ -0,0 +1,40 @@
+/**
+ * AliasTracker - резолвит вызовы через алиасы
+ *
+ * Проблема: `const m = obj.method; m()` не резолвится как method call
+ * Решение: трассируем ASSIGNED_FROM цепочки чтобы найти оригинальный источник
+ *
+ * ИСПОЛЬЗУЕТ:
+ * - VARIABLE -> ASSIGNED_FROM -> EXPRESSION (из JSASTAnalyzer)
+ * - EXPRESSION с expressionType='MemberExpression'
+ *
+ * СОЗДАЁТ:
+ * - CALL -> CALLS -> METHOD/FUNCTION (когда алиас резолвится)
+ * - CALL -> ALIAS_OF -> EXPRESSION (для трассировки)
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class AliasTracker extends Plugin {
+    static MAX_DEPTH: number;
+    private depthExceeded;
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Строит индекс алиасов: file:variableName -> EXPRESSION info
+     * Поддерживает транзитивные цепочки: a = b; b = c; c = obj.method
+     */
+    private buildAliasIndex;
+    /**
+     * Рекурсивно ищет EXPRESSION источник через цепочки ASSIGNED_FROM
+     */
+    private findExpressionSource;
+    /**
+     * Строит индекс методов для резолвинга: className:methodName -> METHOD node
+     */
+    private buildMethodIndex;
+    /**
+     * Пытается резолвить алиасированный method call
+     */
+    private resolveAliasedMethodCall;
+}
+//# sourceMappingURL=AliasTracker.d.ts.map

package/dist/plugins/enrichment/AliasTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AliasTracker.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/AliasTracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAgDhF,qBAAa,YAAa,SAAQ,MAAM;IACtC,MAAM,CAAC,SAAS,SAAM;IACtB,OAAO,CAAC,aAAa,CAA2B;IAEhD,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAmH5D;;;OAGG;YACW,eAAe;IAkC7B;;OAEG;YACW,oBAAoB;IAsDlC;;OAEG;YACW,gBAAgB;IAyB9B;;OAEG;YACW,wBAAwB;CA6EvC"}

package/dist/plugins/enrichment/AliasTracker.js

@@ -0,0 +1,290 @@
+/**
+ * AliasTracker - резолвит вызовы через алиасы
+ *
+ * Проблема: `const m = obj.method; m()` не резолвится как method call
+ * Решение: трассируем ASSIGNED_FROM цепочки чтобы найти оригинальный источник
+ *
+ * ИСПОЛЬЗУЕТ:
+ * - VARIABLE -> ASSIGNED_FROM -> EXPRESSION (из JSASTAnalyzer)
+ * - EXPRESSION с expressionType='MemberExpression'
+ *
+ * СОЗДАЁТ:
+ * - CALL -> CALLS -> METHOD/FUNCTION (когда алиас резолвится)
+ * - CALL -> ALIAS_OF -> EXPRESSION (для трассировки)
+ */
+import { Plugin, createSuccessResult } from '../Plugin.js';
+export class AliasTracker extends Plugin {
+    static MAX_DEPTH = 10;
+    depthExceeded = [];
+    get metadata() {
+        return {
+            name: 'AliasTracker',
+            phase: 'ENRICHMENT',
+            priority: 60, // После MethodCallResolver (50)
+            creates: {
+                nodes: [],
+                edges: ['CALLS', 'ALIAS_OF']
+            }
+        };
+    }
+    async execute(context) {
+        const { graph, onProgress } = context;
+        console.log('[AliasTracker] Starting alias resolution...');
+        let callsProcessed = 0;
+        let aliasesFound = 0;
+        let edgesCreated = 0;
+        let resolvedToMethod = 0;
+        // Трекинг превышений глубины
+        this.depthExceeded = [];
+        // 1. Найти все CALL без object (call sites) которые ещё не резолвлены
+        const unresolvedCalls = [];
+        for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
+            const callNode = node;
+            // Пропускаем method calls (у них есть object)
+            if (callNode.object)
+                continue;
+            // Пропускаем уже резолвленные
+            const existingEdges = await graph.getOutgoingEdges(node.id, ['CALLS']);
+            if (existingEdges.length > 0)
+                continue;
+            unresolvedCalls.push(callNode);
+        }
+        console.log(`[AliasTracker] Found ${unresolvedCalls.length} unresolved call sites`);
+        // 2. Строим индекс алиасов: variableName -> EXPRESSION info
+        const aliasIndex = await this.buildAliasIndex(graph);
+        console.log(`[AliasTracker] Found ${aliasIndex.size} potential aliases`);
+        // 3. Строим индекс методов для резолвинга
+        const methodIndex = await this.buildMethodIndex(graph);
+        // 4. Обрабатываем каждый нерезолвленный вызов
+        for (const call of unresolvedCalls) {
+            callsProcessed++;
+            // Report progress every 50 calls
+            if (onProgress && callsProcessed % 50 === 0) {
+                onProgress({
+                    phase: 'enrichment',
+                    currentPlugin: 'AliasTracker',
+                    message: `Tracking aliases ${callsProcessed}/${unresolvedCalls.length}`,
+                    totalFiles: unresolvedCalls.length,
+                    processedFiles: callsProcessed
+                });
+            }
+            const callName = call.name;
+            const callFile = call.file;
+            // Ищем алиас с таким же именем в том же файле
+            const aliasKey = `${callFile}:${callName}`;
+            const alias = aliasIndex.get(aliasKey);
+            if (!alias)
+                continue;
+            aliasesFound++;
+            // Создаём ALIAS_OF ребро для трассировки
+            await graph.addEdge({
+                src: call.id,
+                dst: alias.expressionId,
+                type: 'ALIAS_OF'
+            });
+            edgesCreated++;
+            // Если это MemberExpression - пробуем резолвить как method call
+            if (alias.expressionType === 'MemberExpression') {
+                const targetMethod = await this.resolveAliasedMethodCall(alias.object, alias.property, callFile, methodIndex, graph, alias.computedPropertyVar // Pass variable name for computed access
+                );
+                if (targetMethod) {
+                    await graph.addEdge({
+                        src: call.id,
+                        dst: targetMethod.id,
+                        type: 'CALLS'
+                    });
+                    edgesCreated++;
+                    resolvedToMethod++;
+                }
+            }
+        }
+        const summary = {
+            callsProcessed,
+            aliasesFound,
+            edgesCreated,
+            resolvedToMethod,
+            aliasesIndexed: aliasIndex.size,
+            depthExceeded: this.depthExceeded.length
+        };
+        // Алярм если были превышения глубины
+        if (this.depthExceeded.length > 0) {
+            console.warn(`[AliasTracker] ⚠️  WARNING: ${this.depthExceeded.length} alias chain(s) exceeded max depth (${AliasTracker.MAX_DEPTH}):`);
+            for (const info of this.depthExceeded) {
+                console.warn(`  - ${info.file}:${info.name} (chain: ${info.chain.join(' → ')}...)`);
+            }
+        }
+        console.log('[AliasTracker] Summary:', summary);
+        return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary);
+    }
+    /**
+     * Строит индекс алиасов: file:variableName -> EXPRESSION info
+     * Поддерживает транзитивные цепочки: a = b; b = c; c = obj.method
+     */
+    async buildAliasIndex(graph) {
+        const index = new Map();
+        // Находим все VARIABLE ноды
+        for await (const varNode of graph.queryNodes({ nodeType: 'VARIABLE' })) {
+            const expressionSource = await this.findExpressionSource(varNode, graph, new Set());
+            if (expressionSource) {
+                const key = `${varNode.file}:${varNode.name}`;
+                index.set(key, {
+                    variableId: varNode.id,
+                    variableName: varNode.name,
+                    ...expressionSource,
+                    file: varNode.file
+                });
+            }
+        }
+        // Также проверяем CONSTANT ноды (const m = obj.method)
+        for await (const constNode of graph.queryNodes({ nodeType: 'CONSTANT' })) {
+            const expressionSource = await this.findExpressionSource(constNode, graph, new Set());
+            if (expressionSource) {
+                const key = `${constNode.file}:${constNode.name}`;
+                index.set(key, {
+                    variableId: constNode.id,
+                    variableName: constNode.name,
+                    ...expressionSource,
+                    file: constNode.file
+                });
+            }
+        }
+        return index;
+    }
+    /**
+     * Рекурсивно ищет EXPRESSION источник через цепочки ASSIGNED_FROM
+     */
+    async findExpressionSource(node, graph, visited, depth = 0, chain = []) {
+        // Добавляем текущую ноду в цепочку
+        chain.push(node.name || node.id);
+        // Защита от бесконечных циклов
+        if (visited.has(node.id.toString()))
+            return null;
+        visited.add(node.id.toString());
+        // Защита от слишком глубоких цепочек
+        if (depth > AliasTracker.MAX_DEPTH) {
+            this.depthExceeded.push({
+                file: node.file,
+                name: chain[0],
+                chain: chain.slice(0, 5),
+                depth: depth
+            });
+            return null;
+        }
+        // Получаем ASSIGNED_FROM рёбра
+        const assignedFromEdges = await graph.getOutgoingEdges(node.id, ['ASSIGNED_FROM']);
+        for (const edge of assignedFromEdges) {
+            const targetNode = await graph.getNode(edge.dst);
+            if (!targetNode)
+                continue;
+            // Если это EXPRESSION - нашли источник!
+            if (targetNode.type === 'EXPRESSION') {
+                return {
+                    expressionId: targetNode.id,
+                    expressionType: targetNode.expressionType,
+                    object: targetNode.object,
+                    property: targetNode.property,
+                    computed: targetNode.computed,
+                    computedPropertyVar: targetNode.computedPropertyVar
+                };
+            }
+            // Если это VARIABLE или CONSTANT - идём глубже (транзитивно)
+            if (targetNode.type === 'VARIABLE' || targetNode.type === 'CONSTANT') {
+                const result = await this.findExpressionSource(targetNode, graph, visited, depth + 1, chain);
+                if (result)
+                    return result;
+            }
+        }
+        return null;
+    }
+    /**
+     * Строит индекс методов для резолвинга: className:methodName -> METHOD node
+     */
+    async buildMethodIndex(graph) {
+        const index = new Map();
+        // Индексируем методы классов
+        for await (const classNode of graph.queryNodes({ nodeType: 'CLASS' })) {
+            const className = classNode.name;
+            if (!className)
+                continue;
+            const containsEdges = await graph.getOutgoingEdges(classNode.id, ['CONTAINS']);
+            for (const edge of containsEdges) {
+                const childNode = await graph.getNode(edge.dst);
+                if (childNode && (childNode.type === 'METHOD' || childNode.type === 'FUNCTION')) {
+                    if (childNode.name) {
+                        // По имени класса
+                        index.set(`${className}:${childNode.name}`, childNode);
+                        // По файлу и имени класса
+                        index.set(`${classNode.file}:${className}:${childNode.name}`, childNode);
+                    }
+                }
+            }
+        }
+        return index;
+    }
+    /**
+     * Пытается резолвить алиасированный method call
+     */
+    async resolveAliasedMethodCall(objectName, propertyName, file, methodIndex, graph, computedPropertyVar = null) {
+        if (!objectName || !propertyName)
+            return null;
+        // Если property вычисляемый - пробуем трассировать через computedPropertyVar
+        if (propertyName === '<computed>') {
+            if (!computedPropertyVar) {
+                return null;
+            }
+            if (!graph.findByAttr) {
+                return null;
+            }
+            const varNodes = await graph.findByAttr({
+                name: computedPropertyVar,
+                file: file
+            });
+            for (const varId of varNodes) {
+                const assignedFromEdges = await graph.getOutgoingEdges(varId, ['ASSIGNED_FROM']);
+                for (const edge of assignedFromEdges) {
+                    const targetNode = await graph.getNode(edge.dst);
+                    if (targetNode && targetNode.type === 'LITERAL' && typeof targetNode.value === 'string') {
+                        propertyName = targetNode.value;
+                        break;
+                    }
+                }
+                if (propertyName !== '<computed>')
+                    break;
+            }
+            if (propertyName === '<computed>') {
+                return null;
+            }
+        }
+        // 1. Проверяем прямое имя класса
+        const directKey = `${objectName}:${propertyName}`;
+        if (methodIndex.has(directKey)) {
+            return methodIndex.get(directKey);
+        }
+        // 2. Проверяем локальный класс в том же файле
+        const localKey = `${file}:${objectName}:${propertyName}`;
+        if (methodIndex.has(localKey)) {
+            return methodIndex.get(localKey);
+        }
+        // 3. Ищем переменную с типом (INSTANCE_OF)
+        if (!graph.findByAttr) {
+            return null;
+        }
+        const varNodes = await graph.findByAttr({
+            name: objectName,
+            file: file
+        });
+        for (const varId of varNodes) {
+            const instanceOfEdges = await graph.getOutgoingEdges(varId, ['INSTANCE_OF']);
+            for (const edge of instanceOfEdges) {
+                const classNode = await graph.getNode(edge.dst);
+                if (classNode && classNode.name) {
+                    const classKey = `${classNode.name}:${propertyName}`;
+                    if (methodIndex.has(classKey)) {
+                        return methodIndex.get(classKey);
+                    }
+                }
+            }
+        }
+        return null;
+    }
+}

package/dist/plugins/enrichment/HTTPConnectionEnricher.d.ts

@@ -0,0 +1,30 @@
+/**
+ * HTTPConnectionEnricher - связывает http:request (frontend) с http:route (backend)
+ *
+ * Создаёт INTERACTS_WITH edges между:
+ * - Frontend fetch('/api/users') → Backend GET /api/users
+ * - Frontend fetch('/api/users', {method: 'POST'}) → Backend POST /api/users
+ *
+ * Поддержка параметризованных путей:
+ * - /api/graph/:serviceId матчится с /api/graph/my-service
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class HTTPConnectionEnricher extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Проверяет совпадают ли пути
+     * Поддерживает параметризованные пути: /api/users/:id матчится с /api/users/123
+     */
+    private pathsMatch;
+    /**
+     * Проверяет есть ли параметры в пути
+     */
+    private hasParams;
+    /**
+     * Убирает дубликаты по ID
+     */
+    private deduplicateById;
+}
+//# sourceMappingURL=HTTPConnectionEnricher.d.ts.map

package/dist/plugins/enrichment/HTTPConnectionEnricher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HTTPConnectionEnricher.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/HTTPConnectionEnricher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA8BhF,qBAAa,sBAAuB,SAAQ,MAAM;IAChD,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAuF5D;;;OAGG;IACH,OAAO,CAAC,UAAU;IAqBlB;;OAEG;IACH,OAAO,CAAC,SAAS;IAIjB;;OAEG;IACH,OAAO,CAAC,eAAe;CAaxB"}