@psiclawops/hypermem 0.5.6 → 0.7.0

package/dist/context-backfill.d.ts

@@ -0,0 +1,46 @@
+/**
+ * hypermem Context Backfill
+ *
+ * One-time migration that creates context rows for existing conversations
+ * that don't yet have an active context. Designed to be idempotent — running
+ * it multiple times produces the same result without modifying existing data.
+ *
+ * Also provides parent chain backfill (Phase 2): reconstructs parent_id/depth
+ * for legacy flat conversations that were created before the Turn DAG model.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+/**
+ * Backfill active contexts for all existing conversations.
+ *
+ * For each conversation without an active context:
+ *   1. Creates an active context via getOrCreateActiveContext
+ *   2. If the conversation has messages, advances the head pointer
+ *      to the highest message ID
+ *
+ * @returns counts of created and skipped conversations
+ */
+export declare function backfillContexts(db: DatabaseSync): {
+    created: number;
+    skipped: number;
+};
+/**
+ * Backfill parent_id and depth for existing messages that lack them.
+ *
+ * Reconstructs a linear chain per conversation ordered by message_index:
+ *   - first message: parent_id = NULL, depth = 0
+ *   - each subsequent: parent_id = previous.id, depth = previous.depth + 1
+ *
+ * Idempotent: only touches messages where parent_id IS NULL AND depth = 0
+ * AND there is more than one message or the message is not the first.
+ * In practice, we simply skip messages that already have parent_id set.
+ *
+ * Also stamps context_id on messages that lack it, using the active context
+ * for their conversation.
+ *
+ * @returns counts of messages updated and conversations processed
+ */
+export declare function backfillParentChains(db: DatabaseSync): {
+    conversationsProcessed: number;
+    messagesUpdated: number;
+};
+//# sourceMappingURL=context-backfill.d.ts.map

package/dist/context-backfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-backfill.d.ts","sourceRoot":"","sources":["../src/context-backfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGhD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,YAAY,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAwCvF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,YAAY,GACf;IAAE,sBAAsB,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAE,CA+D7D"}

package/dist/context-backfill.js

@@ -0,0 +1,113 @@
+/**
+ * hypermem Context Backfill
+ *
+ * One-time migration that creates context rows for existing conversations
+ * that don't yet have an active context. Designed to be idempotent — running
+ * it multiple times produces the same result without modifying existing data.
+ *
+ * Also provides parent chain backfill (Phase 2): reconstructs parent_id/depth
+ * for legacy flat conversations that were created before the Turn DAG model.
+ */
+import { getOrCreateActiveContext, updateContextHead } from './context-store.js';
+/**
+ * Backfill active contexts for all existing conversations.
+ *
+ * For each conversation without an active context:
+ *   1. Creates an active context via getOrCreateActiveContext
+ *   2. If the conversation has messages, advances the head pointer
+ *      to the highest message ID
+ *
+ * @returns counts of created and skipped conversations
+ */
+export function backfillContexts(db) {
+    let created = 0;
+    let skipped = 0;
+    const conversations = db
+        .prepare('SELECT id, agent_id, session_key FROM conversations')
+        .all();
+    for (const conv of conversations) {
+        // Check if an active context already exists for this conversation
+        const existing = db
+            .prepare("SELECT id FROM contexts WHERE conversation_id = ? AND status = 'active'")
+            .get(conv.id);
+        if (existing) {
+            skipped++;
+            continue;
+        }
+        // Find the max message ID for this conversation (may be null if no messages)
+        const maxRow = db
+            .prepare('SELECT MAX(id) as max_id FROM messages WHERE conversation_id = ?')
+            .get(conv.id);
+        const maxId = maxRow?.max_id ?? null;
+        // Create the active context
+        const context = getOrCreateActiveContext(db, conv.agent_id, conv.session_key, conv.id);
+        // If conversation has messages, advance head to the latest
+        if (maxId !== null) {
+            updateContextHead(db, context.id, maxId);
+        }
+        created++;
+    }
+    return { created, skipped };
+}
+/**
+ * Backfill parent_id and depth for existing messages that lack them.
+ *
+ * Reconstructs a linear chain per conversation ordered by message_index:
+ *   - first message: parent_id = NULL, depth = 0
+ *   - each subsequent: parent_id = previous.id, depth = previous.depth + 1
+ *
+ * Idempotent: only touches messages where parent_id IS NULL AND depth = 0
+ * AND there is more than one message or the message is not the first.
+ * In practice, we simply skip messages that already have parent_id set.
+ *
+ * Also stamps context_id on messages that lack it, using the active context
+ * for their conversation.
+ *
+ * @returns counts of messages updated and conversations processed
+ */
+export function backfillParentChains(db) {
+    let conversationsProcessed = 0;
+    let messagesUpdated = 0;
+    // Get all conversations that have at least one non-first message without parent_id.
+    // This is the idempotency guard: after backfill, all messages at index > 0
+    // have parent_id set. The first message (index 0) legitimately has parent_id = NULL.
+    const conversations = db
+        .prepare(`SELECT DISTINCT conversation_id
+       FROM messages
+       WHERE message_index > 0 AND parent_id IS NULL
+       ORDER BY conversation_id`)
+        .all();
+    const updateStmt = db.prepare('UPDATE messages SET parent_id = ?, depth = ?, context_id = COALESCE(context_id, ?) WHERE id = ?');
+    for (const { conversation_id: convId } of conversations) {
+        // Get active context for this conversation (if any)
+        const ctxRow = db
+            .prepare("SELECT id FROM contexts WHERE conversation_id = ? AND status = 'active' LIMIT 1")
+            .get(convId);
+        const contextId = ctxRow?.id ?? null;
+        // Get all messages for this conversation without parent_id, ordered by message_index
+        const messages = db
+            .prepare('SELECT id, message_index FROM messages WHERE conversation_id = ? AND parent_id IS NULL ORDER BY message_index ASC')
+            .all(convId);
+        if (messages.length === 0)
+            continue;
+        // Also get the last message that already HAS a parent_id (if any),
+        // so we can chain the backfilled messages after it.
+        const lastChainedRow = db
+            .prepare('SELECT id, depth FROM messages WHERE conversation_id = ? AND parent_id IS NOT NULL ORDER BY message_index DESC LIMIT 1')
+            .get(convId);
+        let prevId = lastChainedRow?.id ?? null;
+        let prevDepth = lastChainedRow?.depth ?? -1;
+        // If there's no prior chain AND the first unlinked message is truly
+        // message_index 0, start the chain from scratch
+        for (const msg of messages) {
+            const depth = prevDepth + 1;
+            updateStmt.run(prevId, depth, contextId, msg.id);
+            prevId = msg.id;
+            prevDepth = depth;
+            messagesUpdated++;
+        }
+        conversationsProcessed++;
+    }
+    return { conversationsProcessed, messagesUpdated };
+}
+//# sourceMappingURL=context-backfill.js.map

package/dist/context-store.d.ts

@@ -0,0 +1,77 @@
+/**
+ * hypermem Context Store
+ *
+ * Manages the `contexts` table — a durable record of agent conversation
+ * contexts that tracks which session is active, what the current head
+ * message is, and supports archival and forking.
+ *
+ * Each agent + session pair has at most one active context at a time.
+ * Contexts are the anchor point for the compositor: they track the
+ * head message (most recent message included in composed context) and
+ * link back to the underlying conversation.
+ *
+ * Design principles:
+ *   - All functions take DatabaseSync as first arg (standalone, no classes)
+ *   - Fully idempotent — safe to call on every startup
+ *   - Head pointer is monotone-forward (never moves backward)
+ *   - Archive is idempotent (no-op if already archived)
+ */
+import type { DatabaseSync } from 'node:sqlite';
+export interface Context {
+    id: number;
+    agentId: string;
+    sessionKey: string;
+    conversationId: number;
+    headMessageId: number | null;
+    parentContextId: number | null;
+    status: 'active' | 'archived' | 'forked';
+    createdAt: string;
+    updatedAt: string;
+    metadataJson: string | null;
+}
+/**
+ * Add the contexts table and related indexes to an existing messages.db.
+ * Also ALTERs the messages table to add a context_id foreign key column.
+ * Idempotent — safe to call on every startup.
+ */
+export declare function ensureContextSchema(db: DatabaseSync): void;
+/**
+ * Get the active context for an agent + session pair.
+ * Returns null if no active context exists.
+ */
+export declare function getActiveContext(db: DatabaseSync, agentId: string, sessionKey: string): Context | null;
+/**
+ * Get the active context for an agent + session, creating one if none exists.
+ *
+ * If an active context already exists, returns it unchanged.
+ * Otherwise INSERTs a new context with status='active', head_message_id=NULL,
+ * and the given conversationId.
+ *
+ * Idempotent — safe to call repeatedly.
+ */
+export declare function getOrCreateActiveContext(db: DatabaseSync, agentId: string, sessionKey: string, conversationId: number): Context;
+/**
+ * Update the head message pointer for a context.
+ *
+ * Monotone forward: only updates if messageId > current head_message_id
+ * (or current is NULL). This prevents accidental regression of the head
+ * pointer, matching the compaction-fence monotone progress pattern.
+ */
+export declare function updateContextHead(db: DatabaseSync, contextId: number, messageId: number): void;
+/**
+ * Archive a context, setting its status to 'archived'.
+ * Idempotent — no-op if already archived.
+ */
+export declare function archiveContext(db: DatabaseSync, contextId: number): void;
+/**
+ * Rotate a session's active context: archive the current active context
+ * and create a new one, optionally linking back via parent_context_id.
+ *
+ * Used on session restarts/rotations so the new context starts with a
+ * clean head pointer instead of inheriting the stale tail.
+ *
+ * Returns the newly created active context.
+ * If no active context exists, simply creates one (no archive step).
+ */
+export declare function rotateSessionContext(db: DatabaseSync, agentId: string, sessionKey: string, conversationId: number): Context;
+//# sourceMappingURL=context-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context-store.d.ts","sourceRoot":"","sources":["../src/context-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIhD,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,MAAM,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAyBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAmC1D;AAID;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,YAAY,EAChB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,OAAO,GAAG,IAAI,CAShB;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,EAAE,EAAE,YAAY,EAChB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,GACrB,OAAO,CAwBT;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,IAAI,CAeN;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,YAAY,EAChB,SAAS,EAAE,MAAM,GAChB,IAAI,CAMN;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,YAAY,EAChB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,GACrB,OAAO,CA2BT"}

package/dist/context-store.js

@@ -0,0 +1,177 @@
+/**
+ * hypermem Context Store
+ *
+ * Manages the `contexts` table — a durable record of agent conversation
+ * contexts that tracks which session is active, what the current head
+ * message is, and supports archival and forking.
+ *
+ * Each agent + session pair has at most one active context at a time.
+ * Contexts are the anchor point for the compositor: they track the
+ * head message (most recent message included in composed context) and
+ * link back to the underlying conversation.
+ *
+ * Design principles:
+ *   - All functions take DatabaseSync as first arg (standalone, no classes)
+ *   - Fully idempotent — safe to call on every startup
+ *   - Head pointer is monotone-forward (never moves backward)
+ *   - Archive is idempotent (no-op if already archived)
+ */
+// ─── Internal Helpers ───────────────────────────────────────────
+function parseContextRow(row) {
+    return {
+        id: row.id,
+        agentId: row.agent_id,
+        sessionKey: row.session_key,
+        conversationId: row.conversation_id,
+        headMessageId: row.head_message_id ?? null,
+        parentContextId: row.parent_context_id ?? null,
+        status: row.status,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadataJson: row.metadata_json ?? null,
+    };
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+// ─── Schema ─────────────────────────────────────────────────────
+/**
+ * Add the contexts table and related indexes to an existing messages.db.
+ * Also ALTERs the messages table to add a context_id foreign key column.
+ * Idempotent — safe to call on every startup.
+ */
+export function ensureContextSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS contexts (
+      id INTEGER PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      session_key TEXT NOT NULL,
+      conversation_id INTEGER REFERENCES conversations(id),
+      head_message_id INTEGER REFERENCES messages(id),
+      parent_context_id INTEGER REFERENCES contexts(id),
+      status TEXT NOT NULL DEFAULT 'active',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      metadata_json TEXT
+    )
+  `);
+    db.exec(`
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_contexts_active_session
+      ON contexts(agent_id, session_key, status)
+      WHERE status = 'active'
+  `);
+    db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_contexts_head
+      ON contexts(head_message_id)
+  `);
+    // ALTER messages table to add context_id column (PRAGMA guard)
+    const msgCols = db.prepare('PRAGMA table_info(messages)').all().map(r => r.name);
+    if (!msgCols.includes('context_id')) {
+        db.exec('ALTER TABLE messages ADD COLUMN context_id INTEGER REFERENCES contexts(id)');
+    }
+}
+// ─── Context Operations ─────────────────────────────────────────
+/**
+ * Get the active context for an agent + session pair.
+ * Returns null if no active context exists.
+ */
+export function getActiveContext(db, agentId, sessionKey) {
+    const row = db
+        .prepare('SELECT * FROM contexts WHERE agent_id = ? AND session_key = ? AND status = ?')
+        .get(agentId, sessionKey, 'active');
+    if (!row)
+        return null;
+    return parseContextRow(row);
+}
+/**
+ * Get the active context for an agent + session, creating one if none exists.
+ *
+ * If an active context already exists, returns it unchanged.
+ * Otherwise INSERTs a new context with status='active', head_message_id=NULL,
+ * and the given conversationId.
+ *
+ * Idempotent — safe to call repeatedly.
+ */
+export function getOrCreateActiveContext(db, agentId, sessionKey, conversationId) {
+    const existing = getActiveContext(db, agentId, sessionKey);
+    if (existing)
+        return existing;
+    const now = nowIso();
+    const result = db
+        .prepare(`INSERT INTO contexts (agent_id, session_key, conversation_id, head_message_id, parent_context_id, status, created_at, updated_at, metadata_json)
+       VALUES (?, ?, ?, NULL, NULL, 'active', ?, ?, NULL)`)
+        .run(agentId, sessionKey, conversationId, now, now);
+    return {
+        id: Number(result.lastInsertRowid),
+        agentId,
+        sessionKey,
+        conversationId,
+        headMessageId: null,
+        parentContextId: null,
+        status: 'active',
+        createdAt: now,
+        updatedAt: now,
+        metadataJson: null,
+    };
+}
+/**
+ * Update the head message pointer for a context.
+ *
+ * Monotone forward: only updates if messageId > current head_message_id
+ * (or current is NULL). This prevents accidental regression of the head
+ * pointer, matching the compaction-fence monotone progress pattern.
+ */
+export function updateContextHead(db, contextId, messageId) {
+    const now = nowIso();
+    const row = db
+        .prepare('SELECT head_message_id FROM contexts WHERE id = ?')
+        .get(contextId);
+    if (!row)
+        return;
+    // Monotone forward: only advance, never regress
+    if (row.head_message_id === null || messageId > row.head_message_id) {
+        db.prepare('UPDATE contexts SET head_message_id = ?, updated_at = ? WHERE id = ?').run(messageId, now, contextId);
+    }
+}
+/**
+ * Archive a context, setting its status to 'archived'.
+ * Idempotent — no-op if already archived.
+ */
+export function archiveContext(db, contextId) {
+    const now = nowIso();
+    db.prepare(`UPDATE contexts SET status = 'archived', updated_at = ? WHERE id = ? AND status != 'archived'`).run(now, contextId);
+}
+/**
+ * Rotate a session's active context: archive the current active context
+ * and create a new one, optionally linking back via parent_context_id.
+ *
+ * Used on session restarts/rotations so the new context starts with a
+ * clean head pointer instead of inheriting the stale tail.
+ *
+ * Returns the newly created active context.
+ * If no active context exists, simply creates one (no archive step).
+ */
+export function rotateSessionContext(db, agentId, sessionKey, conversationId) {
+    const existing = getActiveContext(db, agentId, sessionKey);
+    if (existing) {
+        archiveContext(db, existing.id);
+    }
+    const now = nowIso();
+    const result = db
+        .prepare(`INSERT INTO contexts (agent_id, session_key, conversation_id, head_message_id, parent_context_id, status, created_at, updated_at, metadata_json)
+       VALUES (?, ?, ?, NULL, ?, 'active', ?, ?, NULL)`)
+        .run(agentId, sessionKey, conversationId, existing?.id ?? null, now, now);
+    return {
+        id: Number(result.lastInsertRowid),
+        agentId,
+        sessionKey,
+        conversationId,
+        headMessageId: null,
+        parentContextId: existing?.id ?? null,
+        status: 'active',
+        createdAt: now,
+        updatedAt: now,
+        metadataJson: null,
+    };
+}
+//# sourceMappingURL=context-store.js.map

package/dist/contradiction-detector.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Contradiction Detector — heuristic-based contradiction detection for the fact store.
+ *
+ * Detects when a newly ingested fact contradicts existing active facts using
+ * vector similarity (when available) and FTS candidate retrieval, scored by
+ * pattern-based heuristics (negation, numeric conflict, state conflict, temporal).
+ *
+ * No LLM calls — v1 is purely heuristic. LLM-enhanced scoring is a future item.
+ */
+import type { FactStore } from './fact-store.js';
+import type { VectorStore } from './vector-store.js';
+export interface ContradictionCandidate {
+    existingFactId: number;
+    existingContent: string;
+    similarityScore: number;
+    contradictionScore: number;
+    reason: string;
+}
+export interface ContradictionResult {
+    contradictions: ContradictionCandidate[];
+    autoResolved: boolean;
+    resolvedCount: number;
+}
+export interface ContradictionDetectorConfig {
+    /** Minimum similarity to consider as candidate. Default: 0.6 */
+    minSimilarity?: number;
+    /** Minimum contradiction score for auto-resolution. Default: 0.85 */
+    autoResolveThreshold?: number;
+    /** Max candidates to evaluate per ingest. Default: 10 */
+    maxCandidates?: number;
+    /** Enable auto-resolution. Default: true */
+    autoResolve?: boolean;
+}
+export declare class ContradictionDetector {
+    private readonly factStore;
+    private readonly vectorStore?;
+    private readonly config;
+    constructor(factStore: FactStore, vectorStore?: VectorStore | undefined, config?: ContradictionDetectorConfig);
+    /**
+     * On fact ingest, check if the new fact contradicts existing active facts.
+     * Uses vector similarity (when available) + FTS to find candidates, then
+     * scores each candidate with heuristic contradiction checks.
+     */
+    detectOnIngest(agentId: string, newFact: {
+        content: string;
+        domain?: string;
+    }): Promise<ContradictionResult>;
+    /**
+     * Resolve a detected contradiction between an existing fact and a new fact.
+     */
+    resolveContradiction(oldFactId: number, newFactId: number, resolution: 'supersede' | 'keep-both' | 'reject-new'): void;
+    /**
+     * Auto-resolve high-confidence contradictions: newer supersedes older.
+     * Only resolves candidates above the autoResolveThreshold.
+     *
+     * @param agentId - The agent whose facts are being resolved (for audit trail)
+     * @param candidates - Scored contradiction candidates from detectOnIngest
+     * @returns Count of auto-resolved contradictions
+     */
+    autoResolve(_agentId: string, candidates: ContradictionCandidate[]): Promise<number>;
+    /**
+     * Find candidate facts that might contradict the new fact.
+     * Uses vector search (if available) and FTS, deduplicates, and returns
+     * up to maxCandidates results above minSimilarity.
+     */
+    private findCandidates;
+    /**
+     * Score a candidate fact against the new fact content for contradiction.
+     * Returns a ContradictionCandidate if any heuristic fires, null otherwise.
+     */
+    private scoreContradiction;
+    /**
+     * Compute Jaccard-like token overlap between two texts.
+     * Returns 0-1 where 1 means identical token sets.
+     */
+    private tokenOverlapSimilarity;
+}
+//# sourceMappingURL=contradiction-detector.d.ts.map

package/dist/contradiction-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contradiction-detector.d.ts","sourceRoot":"","sources":["../src/contradiction-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,mBAAmB,CAAC;AAIzE,MAAM,WAAW,sBAAsB;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,sBAAsB,EAAE,CAAC;IACzC,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,2BAA2B;IAC1C,gEAAgE;IAChE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,yDAAyD;IACzD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4CAA4C;IAC5C,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAkKD,qBAAa,qBAAqB;IAI9B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;IAJ/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwC;gBAG5C,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,WAAW,YAAA,EAC1C,MAAM,CAAC,EAAE,2BAA2B;IAKtC;;;;OAIG;IACG,cAAc,CAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAC5C,OAAO,CAAC,mBAAmB,CAAC;IAuB/B;;OAEG;IACH,oBAAoB,CAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,WAAW,GAAG,WAAW,GAAG,YAAY,GACnD,IAAI;IAcP;;;;;;;OAOG;IACG,WAAW,CACf,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,sBAAsB,EAAE,GACnC,OAAO,CAAC,MAAM,CAAC;IAoBlB;;;;OAIG;YACW,cAAc;IA0E5B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IA0D1B;;;OAGG;IACH,OAAO,CAAC,sBAAsB;CAa/B"}