@psiclawops/hypermem 0.9.1 → 0.9.3

package/dist/knowledge-lint.js

@@ -0,0 +1,155 @@
+/**
+ * Knowledge Lint
+ *
+ * Health checks for the knowledge table:
+ *  1. Stale syntheses — decay confidence on old topic-synthesis entries
+ *  2. Orphan topics — topics with too few messages, stale > 48h
+ *  3. Coverage gaps — topics with many messages but no synthesis
+ */
+import { LINT_STALE_DAYS } from './topic-synthesizer.js';
+// Orphan topics older than this many days are eligible for pruning.
+// 48h = report threshold, 14d = prune threshold (conservative).
+export const ORPHAN_PRUNE_DAYS = 14;
+// ─── lintKnowledge ──────────────────────────────────────────────
+/**
+ * Run lint checks on the knowledge table.
+ *
+ * 1. Stale syntheses: topic-synthesis entries where the source topic's
+ *    updated_at is older than LINT_STALE_DAYS and there are no new messages.
+ *    Marks these with confidence = 0.3.
+ *
+ * 2. Orphan topics: topics with message_count < 3 and updated_at older than 48h.
+ *    Logged but not synthesized.
+ *
+ * 3. Coverage gaps: topics with message_count >= 20 but no corresponding
+ *    knowledge entry (domain='topic-synthesis', key=topic.name).
+ */
+export function lintKnowledge(libraryDb) {
+    const result = {
+        staleDecayed: 0,
+        orphansFound: 0,
+        orphansPruned: 0,
+        coverageGaps: [],
+    };
+    // ── 1. Stale syntheses ─────────────────────────────────────────
+    // Find topic-synthesis knowledge entries whose source topic hasn't been
+    // updated in LINT_STALE_DAYS days.
+    try {
+        const staleSyntheses = libraryDb.prepare(`
+      SELECT k.id, k.source_ref, k.agent_id, k.key
+      FROM knowledge k
+      WHERE k.domain = 'topic-synthesis'
+        AND k.superseded_by IS NULL
+        AND k.updated_at < datetime('now', '-' || ? || ' days')
+    `).all(Math.floor(LINT_STALE_DAYS));
+        for (const entry of staleSyntheses) {
+            // Extract topic id from source_ref: "topic:<id>" or "topic:<id>:mc:<count>"
+            if (!entry.source_ref)
+                continue;
+            const match = entry.source_ref.match(/^topic:(\d+)/);
+            if (!match)
+                continue;
+            const topicId = parseInt(match[1], 10);
+            // Check if topic exists and is stale (no recent updates)
+            let topicRow;
+            try {
+                topicRow = libraryDb.prepare('SELECT updated_at, message_count FROM topics WHERE id = ?').get(topicId);
+            }
+            catch {
+                continue;
+            }
+            if (!topicRow)
+                continue;
+            // Check if topic is stale (updated_at older than LINT_STALE_DAYS)
+            const topicAge = libraryDb.prepare(`
+        SELECT CASE WHEN datetime(?) < datetime('now', '-' || ? || ' days') THEN 1 ELSE 0 END AS is_stale
+      `).get(topicRow.updated_at, Math.floor(LINT_STALE_DAYS));
+            if (topicAge.is_stale) {
+                // Decay confidence to 0.3
+                libraryDb.prepare('UPDATE knowledge SET confidence = 0.3, updated_at = datetime(\'now\') WHERE id = ?').run(entry.id);
+                result.staleDecayed++;
+            }
+        }
+    }
+    catch {
+        // Non-fatal — continue with other checks
+    }
+    // ── 2. Orphan topics ───────────────────────────────────────────
+    // Topics with message_count < 3 and updated_at > 48h ago
+    try {
+        const orphans = libraryDb.prepare(`
+      SELECT id, name, message_count, updated_at FROM topics
+      WHERE message_count < 3
+        AND updated_at < datetime('now', '-48 hours')
+    `).all();
+        result.orphansFound = orphans.length;
+        if (orphans.length > 0) {
+            const sample = orphans.slice(0, 10).map(o => o.name).join(', ');
+            const remainder = Math.max(0, orphans.length - 10);
+            console.log(`[lint] ${orphans.length} orphan topic(s) found (< 3 messages, stale > 48h)` +
+                (sample ? `; sample: ${sample}` : '') +
+                (remainder > 0 ? `; +${remainder} more` : ''));
+        }
+        // Prune orphan topics older than ORPHAN_PRUNE_DAYS (conservative cleanup).
+        // Safety: only prune topics with no knowledge-synthesis entries and no facts
+        // referencing them (via source_ref 'topic:<id>' pattern).
+        try {
+            const prunable = libraryDb.prepare(`
+        SELECT t.id, t.name FROM topics t
+        WHERE t.message_count < 3
+          AND t.updated_at < datetime('now', '-' || ? || ' days')
+          AND NOT EXISTS (
+            SELECT 1 FROM knowledge k
+            WHERE k.agent_id = t.agent_id
+              AND k.domain = 'topic-synthesis'
+              AND k.key = t.name
+              AND k.superseded_by IS NULL
+          )
+          AND NOT EXISTS (
+            SELECT 1 FROM facts f
+            WHERE f.source_ref LIKE 'topic:' || t.id || '%'
+          )
+      `).all(ORPHAN_PRUNE_DAYS);
+            if (prunable.length > 0) {
+                const ids = prunable.map(p => p.id);
+                const placeholders = ids.map(() => '?').join(',');
+                libraryDb.prepare(`DELETE FROM topics WHERE id IN (${placeholders})`).run(...ids);
+                result.orphansPruned = prunable.length;
+                console.log(`[lint] pruned ${prunable.length} orphan topic(s) (< 3 messages, stale > ${ORPHAN_PRUNE_DAYS}d, no syntheses or facts)`);
+            }
+        }
+        catch (err) {
+            console.warn('[lint] orphan prune failed (non-fatal):', err.message);
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+    // ── 3. Coverage gaps ───────────────────────────────────────────
+    // Topics with >= 20 messages but no synthesis in knowledge table
+    try {
+        const bigTopics = libraryDb.prepare(`
+      SELECT t.name, t.agent_id
+      FROM topics t
+      WHERE t.message_count >= 20
+    `).all();
+        for (const topic of bigTopics) {
+            const synthesis = libraryDb.prepare(`
+        SELECT id FROM knowledge
+        WHERE agent_id = ?
+          AND domain = 'topic-synthesis'
+          AND key = ?
+          AND superseded_by IS NULL
+        LIMIT 1
+      `).get(topic.agent_id, topic.name);
+            if (!synthesis) {
+                result.coverageGaps.push(topic.name);
+            }
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+    return result;
+}
+//# sourceMappingURL=knowledge-lint.js.map

package/dist/knowledge-store.d.ts

@@ -0,0 +1,75 @@
+/**
+ * hypermem Knowledge Store
+ *
+ * Long-term structured knowledge — replaces MEMORY.md.
+ * Lives in the central library DB.
+ * Knowledge entries are keyed (domain + key), versioned via superseded_by,
+ * and linked to each other via knowledge_links.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+import type { Knowledge } from './types.js';
+export type LinkType = 'supports' | 'contradicts' | 'depends_on' | 'supersedes' | 'related';
+export declare class KnowledgeStore {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    /**
+     * Upsert a knowledge entry.
+     *
+     * Versioning semantics:
+     * - If no active entry exists: insert as version 1
+     * - If same content: refresh confidence + timestamp + source_ref/expiry
+     *   metadata only (no new version). Refreshing source_ref advances
+     *   synthesis watermarks (e.g. "topic:<id>:mc:<count>") so callers that
+     *   re-run with identical compiled content do not loop forever.
+     * - If different content: insert as new version (max_version + 1), mark
+     *   previous active row as superseded_by = new_id
+     *
+     * This guarantees version history is real rows, not in-place overwrites.
+     * The unique constraint is (agent_id, domain, key, version) so each
+     * version is a distinct row.
+     */
+    upsert(agentId: string, domain: string, key: string, content: string, opts?: {
+        confidence?: number;
+        visibility?: string;
+        sourceType?: string;
+        sourceRef?: string;
+        expiresAt?: string;
+    }): Knowledge;
+    /**
+     * Get current (non-superseded) knowledge for an agent.
+     */
+    getActive(agentId: string, opts?: {
+        domain?: string;
+        limit?: number;
+    }): Knowledge[];
+    /**
+     * Get a specific knowledge entry by domain + key.
+     */
+    get(agentId: string, domain: string, key: string): Knowledge | null;
+    /**
+     * Get the version history of a knowledge entry.
+     */
+    getHistory(agentId: string, domain: string, key: string): Knowledge[];
+    /**
+     * Search knowledge by content.
+     */
+    search(agentId: string, query: string, limit?: number): Knowledge[];
+    /**
+     * List all domains for an agent.
+     */
+    getDomains(agentId: string): string[];
+    /**
+     * Add a link between knowledge entries.
+     */
+    addLink(fromId: number, toId: number, linkType: LinkType): void;
+    /**
+     * Get knowledge count.
+     */
+    getCount(agentId: string): number;
+    /**
+     * Import from MEMORY.md content.
+     * Parses markdown sections into domain/key/content entries.
+     */
+    importFromMarkdown(agentId: string, markdown: string, sourcePath: string): number;
+}
+//# sourceMappingURL=knowledge-store.d.ts.map

package/dist/knowledge-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-store.d.ts","sourceRoot":"","sources":["../src/knowledge-store.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAwB5C,MAAM,MAAM,QAAQ,GAAG,UAAU,GAAG,aAAa,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,CAAC;AAE5F,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,YAAY;IAE7C;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CACJ,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE;QACL,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,GACA,SAAS;IAuGZ;;OAEG;IACH,SAAS,CACP,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,GACA,SAAS,EAAE;IAyBd;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAUnE;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE;IAUrE;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAE,MAAW,GAAG,SAAS,EAAE;IAavE;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IAUrC;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAO/D;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAOjC;;;OAGG;IACH,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;CAwDlF"}

package/dist/knowledge-store.js

@@ -0,0 +1,270 @@
+/**
+ * hypermem Knowledge Store
+ *
+ * Long-term structured knowledge — replaces MEMORY.md.
+ * Lives in the central library DB.
+ * Knowledge entries are keyed (domain + key), versioned via superseded_by,
+ * and linked to each other via knowledge_links.
+ */
+import { isSafeForSharedVisibility, requiresScan } from './secret-scanner.js';
+function nowIso() {
+    return new Date().toISOString();
+}
+function parseKnowledgeRow(row) {
+    return {
+        id: row.id,
+        agentId: row.agent_id,
+        domain: row.domain,
+        key: row.key,
+        content: row.content,
+        confidence: row.confidence,
+        sourceType: row.source_type,
+        sourceRef: row.source_ref || null,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        expiresAt: row.expires_at || null,
+        supersededBy: row.superseded_by || null,
+    };
+}
+export class KnowledgeStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Upsert a knowledge entry.
+     *
+     * Versioning semantics:
+     * - If no active entry exists: insert as version 1
+     * - If same content: refresh confidence + timestamp + source_ref/expiry
+     *   metadata only (no new version). Refreshing source_ref advances
+     *   synthesis watermarks (e.g. "topic:<id>:mc:<count>") so callers that
+     *   re-run with identical compiled content do not loop forever.
+     * - If different content: insert as new version (max_version + 1), mark
+     *   previous active row as superseded_by = new_id
+     *
+     * This guarantees version history is real rows, not in-place overwrites.
+     * The unique constraint is (agent_id, domain, key, version) so each
+     * version is a distinct row.
+     */
+    upsert(agentId, domain, key, content, opts) {
+        const now = nowIso();
+        const sourceType = opts?.sourceType || 'manual';
+        const confidence = opts?.confidence ?? 1.0;
+        // Secret gate: if requested visibility is shared, verify content is clean.
+        // Downgrade to 'private' rather than reject — matches episode-store pattern.
+        let visibility = opts?.visibility ?? 'private';
+        if (requiresScan(visibility) && !isSafeForSharedVisibility(content)) {
+            visibility = 'private';
+        }
+        // Find current active entry (not superseded, not expired)
+        const existing = this.db.prepare(`
+      SELECT * FROM knowledge
+      WHERE agent_id = ? AND domain = ? AND key = ?
+      AND superseded_by IS NULL
+      AND (expires_at IS NULL OR expires_at > datetime('now'))
+      ORDER BY version DESC LIMIT 1
+    `).get(agentId, domain, key);
+        if (existing && existing.content === content) {
+            // Same content — refresh confidence/timestamp and synthesis metadata
+            // (source_ref, source_type, expires_at) so watermark-style refs advance
+            // without minting a new version row.
+            const nextSourceRef = opts?.sourceRef !== undefined
+                ? opts.sourceRef
+                : (existing.source_ref ?? null);
+            const nextSourceType = opts?.sourceType !== undefined
+                ? sourceType
+                : (existing.source_type ?? sourceType);
+            const nextExpiresAt = opts?.expiresAt !== undefined
+                ? opts.expiresAt
+                : (existing.expires_at ?? null);
+            this.db.prepare(`UPDATE knowledge
+           SET confidence = ?, updated_at = ?, source_ref = ?, source_type = ?, expires_at = ?
+         WHERE id = ?`).run(confidence, now, nextSourceRef, nextSourceType, nextExpiresAt, existing.id);
+            return parseKnowledgeRow({
+                ...existing,
+                confidence,
+                updated_at: now,
+                source_ref: nextSourceRef,
+                source_type: nextSourceType,
+                expires_at: nextExpiresAt,
+            });
+        }
+        // Determine next version number
+        const maxVersionRow = this.db.prepare(`
+      SELECT MAX(version) AS max_version FROM knowledge
+      WHERE agent_id = ? AND domain = ? AND key = ?
+    `).get(agentId, domain, key);
+        const nextVersion = (maxVersionRow?.max_version ?? 0) + 1;
+        // Insert new version row (no ON CONFLICT — version column ensures uniqueness)
+        const result = this.db.prepare(`
+      INSERT INTO knowledge
+        (agent_id, domain, key, version, content, confidence, visibility, source_type, source_ref,
+         created_at, updated_at, expires_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(agentId, domain, key, nextVersion, content, confidence, visibility, sourceType, opts?.sourceRef ?? null, now, now, opts?.expiresAt ?? null);
+        const newId = result.lastInsertRowid;
+        // Mark previous active entry as superseded by this new version
+        if (existing) {
+            this.db.prepare('UPDATE knowledge SET superseded_by = ?, updated_at = ? WHERE id = ?').run(newId, now, existing.id);
+            // Link: new version supersedes old version
+            this.addLink(newId, existing.id, 'supersedes');
+        }
+        return {
+            id: newId,
+            agentId,
+            domain,
+            key,
+            content,
+            confidence,
+            sourceType,
+            sourceRef: opts?.sourceRef ?? null,
+            createdAt: now,
+            updatedAt: now,
+            expiresAt: opts?.expiresAt ?? null,
+            supersededBy: null,
+        };
+    }
+    /**
+     * Get current (non-superseded) knowledge for an agent.
+     */
+    getActive(agentId, opts) {
+        let sql = `
+      SELECT * FROM knowledge
+      WHERE agent_id = ?
+      AND superseded_by IS NULL
+      AND (expires_at IS NULL OR expires_at > datetime('now'))
+    `;
+        const params = [agentId];
+        if (opts?.domain) {
+            sql += ' AND domain = ?';
+            params.push(opts.domain);
+        }
+        sql += ' ORDER BY domain, key';
+        if (opts?.limit) {
+            sql += ' LIMIT ?';
+            params.push(opts.limit);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(parseKnowledgeRow);
+    }
+    /**
+     * Get a specific knowledge entry by domain + key.
+     */
+    get(agentId, domain, key) {
+        const row = this.db.prepare(`
+      SELECT * FROM knowledge
+      WHERE agent_id = ? AND domain = ? AND key = ?
+      AND superseded_by IS NULL
+    `).get(agentId, domain, key);
+        return row ? parseKnowledgeRow(row) : null;
+    }
+    /**
+     * Get the version history of a knowledge entry.
+     */
+    getHistory(agentId, domain, key) {
+        const rows = this.db.prepare(`
+      SELECT * FROM knowledge
+      WHERE agent_id = ? AND domain = ? AND key = ?
+      ORDER BY created_at DESC
+    `).all(agentId, domain, key);
+        return rows.map(parseKnowledgeRow);
+    }
+    /**
+     * Search knowledge by content.
+     */
+    search(agentId, query, limit = 20) {
+        const rows = this.db.prepare(`
+      SELECT * FROM knowledge
+      WHERE agent_id = ?
+      AND superseded_by IS NULL
+      AND (content LIKE ? OR key LIKE ?)
+      ORDER BY confidence DESC
+      LIMIT ?
+    `).all(agentId, `%${query}%`, `%${query}%`, limit);
+        return rows.map(parseKnowledgeRow);
+    }
+    /**
+     * List all domains for an agent.
+     */
+    getDomains(agentId) {
+        const rows = this.db.prepare(`
+      SELECT DISTINCT domain FROM knowledge
+      WHERE agent_id = ? AND superseded_by IS NULL
+      ORDER BY domain
+    `).all(agentId);
+        return rows.map(r => r.domain);
+    }
+    /**
+     * Add a link between knowledge entries.
+     */
+    addLink(fromId, toId, linkType) {
+        this.db.prepare(`
+      INSERT OR IGNORE INTO knowledge_links (from_type, from_id, to_type, to_id, link_type, created_at)
+      VALUES ('knowledge', ?, 'knowledge', ?, ?, ?)
+    `).run(fromId, toId, linkType, nowIso());
+    }
+    /**
+     * Get knowledge count.
+     */
+    getCount(agentId) {
+        const row = this.db.prepare('SELECT COUNT(*) AS count FROM knowledge WHERE agent_id = ? AND superseded_by IS NULL').get(agentId);
+        return row.count;
+    }
+    /**
+     * Import from MEMORY.md content.
+     * Parses markdown sections into domain/key/content entries.
+     */
+    importFromMarkdown(agentId, markdown, sourcePath) {
+        const lines = markdown.split('\n');
+        let currentDomain = 'general';
+        let currentKey = '';
+        let currentContent = [];
+        let imported = 0;
+        const flush = () => {
+            if (currentKey && currentContent.length > 0) {
+                this.upsert(agentId, currentDomain, currentKey, currentContent.join('\n').trim(), {
+                    sourceType: 'manual',
+                    sourceRef: sourcePath,
+                });
+                imported++;
+            }
+            currentContent = [];
+        };
+        for (const line of lines) {
+            // ## Section = domain
+            if (line.startsWith('## ')) {
+                flush();
+                currentDomain = line.replace('## ', '').trim().toLowerCase().replace(/\s+/g, '_');
+                currentKey = '';
+                continue;
+            }
+            // ### Subsection or **Bold** = key
+            if (line.startsWith('### ')) {
+                flush();
+                currentKey = line.replace('### ', '').trim();
+                continue;
+            }
+            // - **Key:** Value pattern
+            const kvMatch = line.match(/^[-*]\s+\*\*(.+?)\*\*[:\s]+(.+)/);
+            if (kvMatch) {
+                flush();
+                currentKey = kvMatch[1].trim();
+                currentContent.push(kvMatch[2].trim());
+                continue;
+            }
+            // Regular content line
+            if (currentKey) {
+                currentContent.push(line);
+            }
+            else if (line.trim()) {
+                // Content without a key — use line hash as key
+                currentKey = `note_${lines.indexOf(line)}`;
+                currentContent.push(line);
+            }
+        }
+        flush();
+        return imported;
+    }
+}
+//# sourceMappingURL=knowledge-store.js.map

package/dist/library-schema.d.ts

@@ -0,0 +1,31 @@
+/**
+ * hypermem Library Schema — Fleet-Wide Structured Knowledge
+ *
+ * Single database: ~/.openclaw/hypermem/library.db
+ * The "crown jewel" — durable, backed up, low-write-frequency.
+ *
+ * Collections:
+ *   1. Library entries (versioned docs, specs, reference material)
+ *   2. Facts (agent-learned truths with confidence, visibility, temporal validity)
+ *   3. Preferences (behavioral patterns)
+ *   4. Knowledge/wiki (structured domain knowledge, supersedable topic syntheses)
+ *   5. Episodes (significant events, decisions, discoveries)
+ *   6. Topics (cross-session thread tracking)
+ *   7. Knowledge graph links (relationships between facts, knowledge, topics, episodes)
+ *   8. Fleet registry (agents, orgs, capabilities)
+ *   9. Desired state and config events (drift detection)
+ *  10. System registry and work items (server state, work queues, events)
+ *  11. Session registry and lifecycle events
+ *  12. Document sources/chunks and trigger retrieval metadata
+ *  13. Output standards, model directives, and output metrics
+ *  14. Temporal index, expertise patterns, contradiction audits, and indexer watermarks
+ */
+import { DatabaseSync } from 'node:sqlite';
+export declare const LIBRARY_SCHEMA_VERSION = 19;
+export declare function repairLibraryDb(dbPath: string): {
+    repaired: boolean;
+    backupPath?: string;
+    message: string;
+};
+export declare function migrateLibrary(db: DatabaseSync, engineVersion?: string): void;
+//# sourceMappingURL=library-schema.d.ts.map

package/dist/library-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"library-schema.d.ts","sourceRoot":"","sources":["../src/library-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAo6BzC,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAkF3G;AAID,wBAAgB,cAAc,CAAC,EAAE,EAAE,YAAY,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAoa7E"}