@10et/cli 1.0.0

package/dist/lib/memory-indexer.js

@@ -0,0 +1,418 @@
+/**
+ * Memory Indexer Module
+ *
+ * Indexes journal entries into the memory database.
+ * Runs periodically and on-demand to keep memory system up-to-date.
+ *
+ * @purpose Automatic indexing of journal entries
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { insertMemory, isMemoryIndexed, setLastIndexTimestamp, getAllMemories, getMemoriesWithoutEmbeddings, updateMemoryEmbedding, findMemoryBySourceId, updateMemoryContent, } from './memory-db.js';
+import { computeTFIDF, computeEmbedding } from './memory-search.js';
+import { telemetry } from './telemetry.js';
+/**
+ * Parse a single journal file (JSONL format)
+ */
+async function parseJournalFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n').filter(line => line.trim());
+    const entries = [];
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            entries.push(entry);
+        }
+        catch (error) {
+            console.error(`Failed to parse line in ${filePath}:`, error);
+        }
+    }
+    return entries;
+}
+/**
+ * Get all journal files
+ */
+async function getJournalFiles() {
+    const journalDir = path.join(process.cwd(), '.jfl', 'journal');
+    if (!fs.existsSync(journalDir)) {
+        return [];
+    }
+    const files = fs.readdirSync(journalDir)
+        .filter(file => file.endsWith('.jsonl'))
+        .map(file => path.join(journalDir, file));
+    return files;
+}
+/**
+ * Extract full text content from journal entry
+ */
+function extractContent(entry) {
+    const parts = [
+        entry.title,
+        entry.summary || '',
+        entry.detail || '',
+        (entry.files || []).join(' '),
+        (entry.learned || []).join(' '),
+        entry.next || ''
+    ];
+    return parts.filter(p => p).join('\n\n');
+}
+/**
+ * Index a single journal entry
+ */
+async function indexEntry(entry, allTexts) {
+    if (!entry.session || !entry.ts) {
+        return false;
+    }
+    // Check if already indexed
+    if (await isMemoryIndexed(entry.session, entry.ts)) {
+        return false;
+    }
+    // Extract content
+    const content = extractContent(entry);
+    // Compute TF-IDF tokens
+    const tfIdfTokens = computeTFIDF(content, allTexts);
+    // Try to compute embedding (optional)
+    let embedding;
+    let embeddingModel;
+    try {
+        const embeddingStart = Date.now();
+        const result = await computeEmbedding(content);
+        if (result) {
+            embedding = result.embedding;
+            embeddingModel = result.model;
+            telemetry.track({
+                category: 'performance',
+                event: 'performance:memory_embedding',
+                success: true,
+                duration_ms: Date.now() - embeddingStart,
+                embedding_model: result.model,
+            });
+        }
+    }
+    catch (error) {
+        telemetry.track({
+            category: 'performance',
+            event: 'performance:memory_embedding',
+            success: false,
+            error_type: error.constructor.name,
+        });
+    }
+    // Prepare metadata
+    const metadata = {
+        files: entry.files || [],
+        learned: entry.learned || [],
+        decision: entry.decision || null,
+        incomplete: entry.incomplete || [],
+        next: entry.next || null,
+        status: entry.status || null
+    };
+    // Insert into database
+    await insertMemory({
+        source: 'journal',
+        source_id: entry.session,
+        type: entry.type,
+        title: entry.title,
+        content,
+        summary: entry.summary,
+        metadata,
+        created_at: entry.ts,
+        embedding,
+        embedding_model: embeddingModel,
+        tf_idf_tokens: tfIdfTokens
+    });
+    return true;
+}
+/**
+ * Index all journal entries
+ */
+export async function indexJournalEntries(force = false) {
+    const stats = {
+        added: 0,
+        updated: 0,
+        skipped: 0,
+        errors: 0
+    };
+    try {
+        // Get all journal files
+        const journalFiles = await getJournalFiles();
+        if (journalFiles.length === 0) {
+            return stats;
+        }
+        // Parse all entries
+        const allEntries = [];
+        for (const file of journalFiles) {
+            try {
+                const entries = await parseJournalFile(file);
+                allEntries.push(...entries);
+            }
+            catch (error) {
+                console.error(`Failed to parse ${file}:`, error);
+                stats.errors++;
+            }
+        }
+        // Get all content for TF-IDF computation
+        const allTexts = allEntries.map(entry => extractContent(entry));
+        // Index each entry
+        for (const entry of allEntries) {
+            try {
+                const added = await indexEntry(entry, allTexts);
+                if (added) {
+                    stats.added++;
+                }
+                else {
+                    stats.skipped++;
+                }
+            }
+            catch (error) {
+                console.error(`Failed to index entry ${entry.title}:`, error);
+                stats.errors++;
+            }
+        }
+        // Update last index timestamp
+        await setLastIndexTimestamp(new Date().toISOString());
+    }
+    catch (error) {
+        console.error('Failed to index journal entries:', error);
+        stats.errors++;
+    }
+    return stats;
+}
+// ============================================================================
+// Code Header Indexing
+// ============================================================================
+/**
+ * Scan source files for @purpose headers and index them into memory DB.
+ * Files are deduped by path — if a file's @purpose changed, the memory is updated.
+ * Runs less frequently than journal indexing (code changes less often).
+ */
+export async function indexCodeHeaders() {
+    const stats = { added: 0, updated: 0, skipped: 0, errors: 0 };
+    const projectRoot = process.cwd();
+    const searchDirs = [
+        path.join(projectRoot, "src"),
+        path.join(projectRoot, "app"),
+        path.join(projectRoot, "lib"),
+        path.join(projectRoot, "components"),
+        path.join(projectRoot, "packages"),
+        path.join(projectRoot, "scripts"),
+        path.join(projectRoot, "eval"),
+    ];
+    const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".rs", ".py", ".go", ".sh"];
+    const files = [];
+    function scanDir(dir, depth = 0) {
+        if (depth > 5 || files.length >= 200)
+            return;
+        if (!fs.existsSync(dir))
+            return;
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (files.length >= 200)
+                    break;
+                if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "__tests__")
+                    continue;
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    scanDir(fullPath, depth + 1);
+                }
+                else if (extensions.some(ext => entry.name.endsWith(ext))) {
+                    try {
+                        // Read first 500 bytes — @purpose is always near the top
+                        const fd = fs.openSync(fullPath, 'r');
+                        const buf = Buffer.alloc(500);
+                        fs.readSync(fd, buf, 0, 500, 0);
+                        fs.closeSync(fd);
+                        const head = buf.toString('utf-8');
+                        const match = head.match(/@purpose\s+(.+?)(?:\n|\*)/i);
+                        if (match) {
+                            files.push({
+                                filePath: fullPath,
+                                purpose: match[1].trim(),
+                                relativePath: path.relative(projectRoot, fullPath),
+                            });
+                        }
+                    }
+                    catch { }
+                }
+            }
+        }
+        catch { }
+    }
+    for (const dir of searchDirs) {
+        scanDir(dir);
+    }
+    if (files.length === 0)
+        return stats;
+    // Get all content for TF-IDF
+    const allTexts = files.map(f => `${f.relativePath} ${f.purpose}`);
+    for (const file of files) {
+        try {
+            const sourceId = file.relativePath;
+            const content = `${file.relativePath}: ${file.purpose}`;
+            const existing = await findMemoryBySourceId('file', sourceId);
+            if (existing) {
+                // Check if purpose changed
+                if (existing.content === content) {
+                    stats.skipped++;
+                }
+                else {
+                    await updateMemoryContent(existing.id, content, file.relativePath, file.purpose);
+                    stats.updated++;
+                }
+            }
+            else {
+                // New file — insert
+                const tfIdfTokens = computeTFIDF(content, allTexts);
+                let embedding;
+                let embeddingModel;
+                try {
+                    const result = await computeEmbedding(content);
+                    if (result) {
+                        embedding = result.embedding;
+                        embeddingModel = result.model;
+                    }
+                }
+                catch { }
+                await insertMemory({
+                    source: 'file',
+                    source_id: sourceId,
+                    type: 'code-header',
+                    title: file.relativePath,
+                    content,
+                    summary: file.purpose,
+                    metadata: { path: file.filePath },
+                    created_at: new Date().toISOString(),
+                    embedding,
+                    embedding_model: embeddingModel,
+                    tf_idf_tokens: tfIdfTokens,
+                });
+                stats.added++;
+            }
+        }
+        catch (err) {
+            stats.errors++;
+        }
+    }
+    return stats;
+}
+/**
+ * Recompute TF-IDF for all memories
+ * Used when corpus changes significantly
+ */
+export async function recomputeTFIDF() {
+    const memories = await getAllMemories();
+    if (memories.length === 0) {
+        return 0;
+    }
+    const allTexts = memories.map((m) => m.content);
+    let updated = 0;
+    for (const memory of memories) {
+        try {
+            const tfIdfTokens = computeTFIDF(memory.content, allTexts);
+            // Update memory with new TF-IDF tokens
+            // Note: This would require an update function in memory-db
+            // For now, this is a placeholder
+            updated++;
+        }
+        catch (error) {
+            console.error(`Failed to recompute TF-IDF for memory ${memory.id}:`, error);
+        }
+    }
+    return updated;
+}
+/**
+ * Backfill embeddings for memories that were indexed without them
+ * (e.g. when OpenAI key was expired and fallback wasn't working)
+ */
+export async function backfillEmbeddings() {
+    const missing = await getMemoriesWithoutEmbeddings();
+    let updated = 0;
+    let errors = 0;
+    let consecutiveNulls = 0;
+    for (const memory of missing) {
+        try {
+            // Truncate content to ~8000 tokens (~30K chars) for embedding models
+            const content = memory.content.length > 28000
+                ? memory.content.slice(0, 28000)
+                : memory.content;
+            const result = await computeEmbedding(content);
+            if (result) {
+                await updateMemoryEmbedding(memory.id, result.embedding, result.model);
+                updated++;
+                consecutiveNulls = 0;
+            }
+            else {
+                consecutiveNulls++;
+                // Only stop if we get 3 nulls in a row (API key truly missing)
+                // A single null might just be a too-long or malformed input
+                if (consecutiveNulls >= 3)
+                    break;
+            }
+        }
+        catch (err) {
+            errors++;
+            // Rate limit — back off and stop
+            if (err?.status === 429)
+                break;
+        }
+    }
+    return { updated, errors };
+}
+// Periodic indexing state
+let indexingInterval = null;
+/**
+ * Start periodic indexing
+ */
+export function startPeriodicIndexing(intervalMs = 60000) {
+    if (indexingInterval) {
+        return;
+    }
+    // Run backfill once on first tick (catch up missed embeddings from past sessions)
+    let backfillDone = false;
+    let tickCount = 0;
+    indexingInterval = setInterval(async () => {
+        tickCount++;
+        try {
+            const indexStart = Date.now();
+            const stats = await indexJournalEntries();
+            // Backfill missing embeddings — once per hub lifecycle, then when new entries added
+            let embeddingStats = { updated: 0, errors: 0 };
+            if (!backfillDone || stats.added > 0) {
+                embeddingStats = await backfillEmbeddings();
+                if (embeddingStats.updated === 0 && embeddingStats.errors === 0) {
+                    backfillDone = true; // All caught up — stop checking every tick
+                }
+            }
+            // Index code headers every 5 minutes (every 5th tick at 60s interval)
+            let codeStats = { added: 0, updated: 0, skipped: 0, errors: 0 };
+            if (tickCount === 1 || tickCount % 5 === 0) {
+                codeStats = await indexCodeHeaders();
+            }
+            telemetry.track({
+                category: 'performance',
+                event: 'performance:memory_index',
+                entries_added: stats.added,
+                entries_skipped: stats.skipped,
+                entries_errors: stats.errors,
+                total_entries: stats.added + stats.skipped + stats.errors,
+                duration_ms: Date.now() - indexStart,
+                embeddings_backfilled: embeddingStats.updated,
+                code_headers_added: codeStats.added,
+                code_headers_updated: codeStats.updated,
+            });
+        }
+        catch (error) {
+            console.error('Periodic indexing failed:', error);
+        }
+    }, intervalMs);
+}
+/**
+ * Stop periodic indexing
+ */
+export function stopPeriodicIndexing() {
+    if (indexingInterval) {
+        clearInterval(indexingInterval);
+        indexingInterval = null;
+    }
+}
+//# sourceMappingURL=memory-indexer.js.map

package/dist/lib/memory-indexer.js.map

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

package/dist/lib/memory-search.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Memory Search Module
+ *
+ * Hybrid search combining TF-IDF (fast, always available) and
+ * embeddings (semantic, optional). Provides relevance scoring
+ * and result ranking.
+ *
+ * Key optimizations:
+ * - Stopword removal for cleaner term matching
+ * - Phrase detection for multi-word queries
+ * - Adaptive BM25 b parameter based on corpus statistics
+ * - BM25+ variant with positive IDF floor for better NDCG
+ * - Query term weighting based on IDF for discriminative power
+ * - Reciprocal rank fusion for hybrid score merging
+ * - Pivoted document length normalization
+ *
+ * @purpose Fast and semantic search across indexed memories
+ */
+import { Memory } from './memory-db.js';
+export interface SearchResult {
+    memory: Memory;
+    score: number;
+    relevance: 'high' | 'medium' | 'low';
+}
+export interface SearchOptions {
+    maxItems?: number;
+    type?: string;
+    since?: string;
+    method?: 'tfidf' | 'embedding' | 'hybrid' | 'bm25';
+    rerank?: boolean;
+    /** Use legacy tokenization (no stopwords/phrases) */
+    legacyTokenize?: boolean;
+    /** Use BM25+ variant with positive IDF floor (default: true) */
+    bm25Plus?: boolean;
+    /** Use reciprocal rank fusion for hybrid merging (default: true) */
+    useRRF?: boolean;
+    /** RRF k parameter - higher values smooth rank differences (default: 60) */
+    rrfK?: number;
+}
+/**
+ * BM25+ IDF calculation with positive floor.
+ *
+ * Standard BM25 IDF: log((N - df + 0.5) / (df + 0.5))
+ * This can go NEGATIVE when df > N/2, penalizing common terms.
+ *
+ * BM25+ adds a floor of δ (typically 1) to ensure all matching terms
+ * contribute positively:
+ *
+ *   IDF+ = max(0, log((N - df + 0.5) / (df + 0.5))) + δ
+ *
+ * This improves NDCG for queries containing common relevant terms.
+ *
+ * @param N - Total number of documents
+ * @param df - Document frequency of term
+ * @param delta - Positive floor value (default: 1)
+ */
+declare function computeBM25PlusIDF(N: number, df: number, delta?: number): number;
+/**
+ * Compute query term weights based on corpus IDF.
+ *
+ * Terms that are rarer in the corpus get higher weights, improving
+ * discrimination. This is especially important for short queries
+ * where every term matters.
+ *
+ * Weight formula: softmax(IDF scores) to normalize to probability distribution
+ *
+ * @param queryTokens - Tokenized query terms
+ * @param docFreq - Map of term -> document frequency
+ * @param N - Total number of documents
+ */
+declare function computeQueryTermWeights(queryTokens: string[], docFreq: Map<string, number>, N: number): Map<string, number>;
+/**
+ * Reciprocal Rank Fusion (RRF) for combining multiple ranked lists.
+ *
+ * RRF is more robust than linear score combination because it:
+ * 1. Doesn't require score normalization
+ * 2. Is less sensitive to outlier scores
+ * 3. Naturally handles different score scales
+ *
+ * Formula: RRF(d) = Σ 1 / (k + rank_i(d))
+ *
+ * where k is a smoothing constant (typically 60) that controls
+ * how much rank differences matter.
+ *
+ * @param rankings - Array of ranked result lists
+ * @param k - Smoothing constant (higher = smoother rank differences)
+ */
+declare function reciprocalRankFusion(rankings: SearchResult[][], k?: number): Map<number, number>;
+/**
+ * Pivoted document length normalization.
+ *
+ * Standard BM25 length normalization can over-penalize long documents
+ * or under-penalize short ones depending on b. Pivoted normalization
+ * provides a more balanced approach:
+ *
+ *   norm = 1 - s + s * (dl / pivot)
+ *
+ * where:
+ * - s is the slope (similar to b, typically 0.2-0.4)
+ * - pivot is a calibrated average length (can be tuned)
+ *
+ * This produces more stable rankings across varying document lengths.
+ *
+ * @param dl - Document length
+ * @param avgdl - Average document length
+ * @param s - Slope parameter (default: 0.2)
+ * @param pivotFactor - Pivot as factor of avgdl (default: 1.0)
+ */
+declare function pivotedLengthNorm(dl: number, avgdl: number, s?: number, pivotFactor?: number): number;
+/**
+ * Compute TF-IDF scores for text.
+ *
+ * Uses advanced tokenization with stopword removal and phrase detection
+ * for cleaner term matching.
+ *
+ * @param text - Text to compute TF-IDF for
+ * @param allTexts - Corpus of all documents (for IDF calculation)
+ * @param legacy - Use legacy tokenization (no preprocessing)
+ */
+export declare function computeTFIDF(text: string, allTexts: string[], legacy?: boolean): Record<string, number>;
+/**
+ * Compute adaptive BM25 b parameter based on corpus statistics.
+ *
+ * The b parameter controls length normalization:
+ * - b=0: No length normalization (favor longer docs with more term matches)
+ * - b=1: Full length normalization (treat all docs equally regardless of length)
+ *
+ * Adaptive tuning based on corpus variance:
+ * - High variance in doc lengths → higher b (need more normalization)
+ * - Low variance → lower b (docs are similar length, less normalization needed)
+ *
+ * For journal entries (typically 100-500 tokens), we start with b=0.65 as baseline
+ * and adjust based on actual corpus statistics.
+ */
+declare function computeAdaptiveB(docLengths: number[]): number;
+/**
+ * Compute embedding for text using OpenAI
+ */
+declare function computeEmbedding(text: string): Promise<{
+    embedding: Float32Array;
+    model: string;
+} | null>;
+/**
+ * Main search function.
+ *
+ * Supports multiple search methods with advanced preprocessing:
+ * - bm25: BM25/BM25+ scoring with adaptive length normalization
+ * - tfidf: Classic TF-IDF scoring
+ * - embedding: Semantic search with embeddings
+ * - hybrid: Combined BM25 + embedding with RRF (default)
+ *
+ * All methods use stopword removal and phrase detection by default.
+ * Set legacyTokenize=true to use original tokenization.
+ *
+ * New options for improved ranking:
+ * - bm25Plus: Use BM25+ variant with positive IDF floor (default: true)
+ * - useRRF: Use reciprocal rank fusion for hybrid (default: true)
+ * - rrfK: RRF smoothing constant (default: 60)
+ */
+export declare function searchMemories(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+/**
+ * Export compute embedding for use in indexer
+ */
+export { computeEmbedding };
+/**
+ * Export adaptive B parameter computation for testing and external use
+ */
+export { computeAdaptiveB };
+/**
+ * Export BM25+ IDF computation for testing
+ */
+export { computeBM25PlusIDF };
+/**
+ * Export query term weight computation for testing
+ */
+export { computeQueryTermWeights };
+/**
+ * Export reciprocal rank fusion for testing
+ */
+export { reciprocalRankFusion };
+/**
+ * Export pivoted length normalization for testing
+ */
+export { pivotedLengthNorm };
+//# sourceMappingURL=memory-search.d.ts.map

package/dist/lib/memory-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-search.d.ts","sourceRoot":"","sources":["../../src/lib/memory-search.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EAAE,MAAM,EAAwC,MAAM,gBAAgB,CAAA;AAO7E,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAA;CACrC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,OAAO,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAA;IAClD,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,qDAAqD;IACrD,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,gEAAgE;IAChE,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,oEAAoE;IACpE,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,4EAA4E;IAC5E,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAuBD;;;;;;;;;;;;;;;;GAgBG;AACH,iBAAS,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,GAAE,MAAU,GAAG,MAAM,CAG5E;AAED;;;;;;;;;;;;GAYG;AACH,iBAAS,uBAAuB,CAC9B,WAAW,EAAE,MAAM,EAAE,EACrB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,CAAC,EAAE,MAAM,GACR,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA2BrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,iBAAS,oBAAoB,CAC3B,QAAQ,EAAE,YAAY,EAAE,EAAE,EAC1B,CAAC,GAAE,MAAW,GACb,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAYrB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,iBAAS,iBAAiB,CACxB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,CAAC,GAAE,MAAY,EACf,WAAW,GAAE,MAAY,GACxB,MAAM,CAGR;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAAE,EAClB,MAAM,GAAE,OAAe,GACtB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA0CxB;AAmDD;;;;;;;;;;;;;GAaG;AACH,iBAAS,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAoBtD;AA4GD;;GAEG;AACH,iBAAe,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACrD,SAAS,EAAE,YAAY,CAAA;IACvB,KAAK,EAAE,MAAM,CAAA;CACd,GAAG,IAAI,CAAC,CAuDR;AAsPD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,EAAE,CAAC,CA2CzB;AAYD;;GAEG;AACH,OAAO,EAAE,gBAAgB,EAAE,CAAA;AAE3B;;GAEG;AACH,OAAO,EAAE,gBAAgB,EAAE,CAAA;AAE3B;;GAEG;AACH,OAAO,EAAE,kBAAkB,EAAE,CAAA;AAE7B;;GAEG;AACH,OAAO,EAAE,uBAAuB,EAAE,CAAA;AAElC;;GAEG;AACH,OAAO,EAAE,oBAAoB,EAAE,CAAA;AAE/B;;GAEG;AACH,OAAO,EAAE,iBAAiB,EAAE,CAAA"}