@psiclawops/hypermem 0.1.0

package/dist/preservation-gate.js

@@ -0,0 +1,150 @@
+/**
+ * HyperMem Preservation Gate
+ *
+ * Verifies that a proposed compaction summary preserves the semantic
+ * content of its source messages by measuring geometric fidelity in
+ * embedding space.
+ *
+ * Before a summary replaces raw messages, it must pass two checks:
+ *
+ *   1. Centroid Alignment — the summary embedding must be close to the
+ *      centroid of the source message embeddings (cos similarity).
+ *
+ *   2. Source Coverage — the summary must have positive cosine similarity
+ *      with each individual source message (averaged).
+ *
+ * If the combined preservation score falls below the threshold, the
+ * summary is rejected. The caller should fall back to extractive
+ * compaction (concatenation/selection) rather than accepting a
+ * semantically drifted summary.
+ *
+ * This prevents the silent failure mode where a confident summarizer
+ * produces fluent text that has drifted away from the original meaning
+ * in vector space — making it unretrievable by the very system that
+ * will later search for it.
+ *
+ * Inspired by the Nomic-space preservation gate in openclaw-memory-libravdb
+ * (mathematics-v2.md §5.3), adapted for our Ollama + sqlite-vec stack.
+ */
+import { generateEmbeddings } from './vector-store.js';
+const DEFAULT_PRESERVATION_CONFIG = {
+    threshold: 0.65,
+};
+// ─── Math Utilities ─────────────────────────────────────────────
+/**
+ * Cosine similarity between two Float32Arrays.
+ * Returns value in [-1, 1]. Handles zero-norm vectors gracefully (returns 0).
+ */
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
+    }
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    if (denom === 0)
+        return 0;
+    return dot / denom;
+}
+/**
+ * Compute the centroid (element-wise mean) of an array of vectors.
+ */
+function computeCentroid(vectors) {
+    if (vectors.length === 0) {
+        throw new Error('Cannot compute centroid of empty vector set');
+    }
+    const dim = vectors[0].length;
+    const centroid = new Float32Array(dim);
+    for (const vec of vectors) {
+        for (let i = 0; i < dim; i++) {
+            centroid[i] += vec[i];
+        }
+    }
+    const n = vectors.length;
+    for (let i = 0; i < dim; i++) {
+        centroid[i] /= n;
+    }
+    return centroid;
+}
+// ─── Preservation Gate ──────────────────────────────────────────
+/**
+ * Verify that a summary preserves its source content in embedding space.
+ *
+ * SYNCHRONOUS PATH — for when you already have pre-computed embeddings
+ * (e.g., from the background indexer or vector store cache).
+ *
+ * This is the preferred path: no network calls, no async, deterministic.
+ *
+ * @param summaryEmbedding - The embedding of the proposed summary
+ * @param sourceEmbeddings - Embeddings of the source messages being replaced
+ * @param config - Preservation threshold config
+ */
+export function verifyPreservationFromVectors(summaryEmbedding, sourceEmbeddings, config = {}) {
+    const threshold = config.threshold ?? DEFAULT_PRESERVATION_CONFIG.threshold;
+    if (sourceEmbeddings.length === 0) {
+        return {
+            alignment: 0,
+            coverage: 0,
+            score: 0,
+            passed: false,
+            threshold,
+        };
+    }
+    // 1. Centroid alignment
+    const centroid = computeCentroid(sourceEmbeddings);
+    const alignment = cosineSimilarity(summaryEmbedding, centroid);
+    // 2. Source coverage (average positive cosine similarity)
+    let coverageSum = 0;
+    for (const src of sourceEmbeddings) {
+        coverageSum += Math.max(0, cosineSimilarity(summaryEmbedding, src));
+    }
+    const coverage = coverageSum / sourceEmbeddings.length;
+    // 3. Combined score, clamped to [0, 1]
+    const rawScore = (alignment + coverage) / 2;
+    const score = Math.max(0, Math.min(1, rawScore));
+    return {
+        alignment,
+        coverage,
+        score,
+        passed: score >= threshold,
+        threshold,
+    };
+}
+/**
+ * Verify that a summary preserves its source content in embedding space.
+ *
+ * ASYNC PATH — generates embeddings via Ollama on demand.
+ * Use when pre-computed embeddings aren't available.
+ *
+ * This makes N+1 embedding calls (1 for summary, N for sources if not cached).
+ * For batch compaction, prefer pre-computing embeddings and using the sync path.
+ *
+ * @param summaryText - The proposed summary text
+ * @param sourceTexts - The source message texts being replaced
+ * @param config - Preservation threshold and embedding config
+ */
+export async function verifyPreservation(summaryText, sourceTexts, config = {}) {
+    const threshold = config.threshold ?? DEFAULT_PRESERVATION_CONFIG.threshold;
+    if (sourceTexts.length === 0) {
+        return {
+            alignment: 0,
+            coverage: 0,
+            score: 0,
+            passed: false,
+            threshold,
+        };
+    }
+    // Batch all texts into one embedding call for efficiency
+    const allTexts = [summaryText, ...sourceTexts];
+    const allEmbeddings = await generateEmbeddings(allTexts, config.embedding);
+    const summaryEmbedding = allEmbeddings[0];
+    const sourceEmbeddings = allEmbeddings.slice(1);
+    return verifyPreservationFromVectors(summaryEmbedding, sourceEmbeddings, config);
+}
+//# sourceMappingURL=preservation-gate.js.map

package/dist/provider-translator.d.ts

@@ -0,0 +1,40 @@
+/**
+ * HyperMem Provider Translator
+ *
+ * Converts between provider-neutral (NeutralMessage) and provider-specific formats.
+ * This is the ONLY place where provider-specific formatting exists.
+ * Storage is always neutral. Translation happens at the send/receive boundary.
+ *
+ * This eliminates grafting/stripping entirely — tool calls are stored as structured
+ * data, and each provider gets the format it expects at send time.
+ */
+import type { NeutralMessage, NeutralToolResult, ProviderMessage } from './types.js';
+/**
+ * Generate a HyperMem-native tool call ID.
+ * These are provider-neutral and deterministic within a session.
+ */
+export declare function generateToolCallId(): string;
+/**
+ * Convert a provider-specific tool call ID to a HyperMem ID.
+ * Deterministic: same input always produces same output.
+ */
+export declare function normalizeToolCallId(providerId: string): string;
+export type ProviderType = 'anthropic' | 'openai' | 'openai-responses' | 'unknown';
+export declare function detectProvider(providerString: string | null | undefined): ProviderType;
+/**
+ * Convert neutral messages to provider-specific format.
+ */
+export declare function toProviderFormat(messages: NeutralMessage[], provider: string | null | undefined): ProviderMessage[];
+/**
+ * Convert a provider-specific response to neutral format.
+ */
+export declare function fromProviderFormat(response: Record<string, unknown>, provider: string): NeutralMessage;
+/**
+ * Convert a user message (from chat input) to neutral format.
+ */
+export declare function userMessageToNeutral(content: string, metadata?: Record<string, unknown>): NeutralMessage;
+/**
+ * Convert tool results to a neutral user message.
+ */
+export declare function toolResultsToNeutral(results: NeutralToolResult[]): NeutralMessage;
+//# sourceMappingURL=provider-translator.d.ts.map

package/dist/provider-translator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-translator.d.ts","sourceRoot":"","sources":["../src/provider-translator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,cAAc,EAEd,iBAAiB,EACjB,eAAe,EAChB,MAAM,YAAY,CAAC;AAOpB;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAK3C;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAI9D;AAID,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,QAAQ,GAAG,kBAAkB,GAAG,SAAS,CAAC;AAEnF,wBAAgB,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,YAAY,CAOtF;AAgMD;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EAAE,EAC1B,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAClC,eAAe,EAAE,CAcnB;AA8ED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,QAAQ,EAAE,MAAM,GACf,cAAc,CAYhB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,cAAc,CAQxG;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,iBAAiB,EAAE,GAAG,cAAc,CAOjF"}

package/dist/provider-translator.js

@@ -0,0 +1,349 @@
+/**
+ * HyperMem Provider Translator
+ *
+ * Converts between provider-neutral (NeutralMessage) and provider-specific formats.
+ * This is the ONLY place where provider-specific formatting exists.
+ * Storage is always neutral. Translation happens at the send/receive boundary.
+ *
+ * This eliminates grafting/stripping entirely — tool calls are stored as structured
+ * data, and each provider gets the format it expects at send time.
+ */
+import { createHash } from 'node:crypto';
+// ─── ID Generation ───────────────────────────────────────────────
+let idCounter = 0;
+/**
+ * Generate a HyperMem-native tool call ID.
+ * These are provider-neutral and deterministic within a session.
+ */
+export function generateToolCallId() {
+    idCounter++;
+    const timestamp = Date.now().toString(36);
+    const counter = idCounter.toString(36).padStart(4, '0');
+    return `hm_${timestamp}_${counter}`;
+}
+/**
+ * Convert a provider-specific tool call ID to a HyperMem ID.
+ * Deterministic: same input always produces same output.
+ */
+export function normalizeToolCallId(providerId) {
+    if (providerId.startsWith('hm_'))
+        return providerId; // already normalized
+    const hash = createHash('sha256').update(providerId).digest('hex').substring(0, 12);
+    return `hm_${hash}`;
+}
+export function detectProvider(providerString) {
+    if (!providerString)
+        return 'unknown';
+    const lower = providerString.toLowerCase();
+    if (lower.includes('anthropic') || lower.includes('claude'))
+        return 'anthropic';
+    if (lower.includes('codex') || lower.includes('responses'))
+        return 'openai-responses';
+    if (lower.includes('openai') || lower.includes('gpt') || lower.includes('copilot'))
+        return 'openai';
+    return 'unknown';
+}
+// ─── To Provider Format ──────────────────────────────────────────
+/**
+ * Convert neutral messages to Anthropic Messages API format.
+ *
+ * Prompt caching (DYNAMIC_BOUNDARY):
+ * Anthropic supports prompt caching via cache_control on content blocks.
+ * The last system message BEFORE the dynamicBoundary marker gets
+ * cache_control: {type: "ephemeral"} to mark the static/dynamic boundary.
+ *
+ * Static (cacheable): system prompt + identity — stable across sessions
+ * Dynamic (not cacheable): context block (facts/recall), conversation history
+ *
+ * This allows Anthropic to cache the static prefix and skip re-tokenizing it.
+ */
+function toAnthropic(messages) {
+    const result = [];
+    // Find the last static system message index (before any dynamicBoundary message)
+    // so we can mark it with cache_control.
+    let lastStaticSystemIdx = -1;
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg.role === 'system' && !msg.metadata?.dynamicBoundary) {
+            lastStaticSystemIdx = i;
+        }
+        else if (msg.metadata?.dynamicBoundary) {
+            // Stop scanning — everything after the boundary marker is dynamic
+            break;
+        }
+    }
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg.role === 'system') {
+            // Anthropic system messages are handled separately (system parameter)
+            // Include them as-is; the gateway will extract them.
+            // Mark the last static system message as the cache boundary.
+            const isLastStatic = i === lastStaticSystemIdx;
+            const providerMsg = {
+                role: 'system',
+                content: msg.textContent || '',
+            };
+            if (isLastStatic) {
+                // Add cache_control as a hint to the gateway/Anthropic API.
+                // The gateway is responsible for lifting this into the correct API position.
+                providerMsg.cache_control = { type: 'ephemeral' };
+            }
+            result.push(providerMsg);
+            continue;
+        }
+        if (msg.role === 'assistant') {
+            const content = [];
+            if (msg.textContent) {
+                content.push({ type: 'text', text: msg.textContent });
+            }
+            if (msg.toolCalls) {
+                for (const tc of msg.toolCalls) {
+                    // tc may be a NeutralToolCall { id, name, arguments: string }
+                    // or a raw OpenClaw content block { type, id, name, input: object }
+                    const rawTc = tc;
+                    let input;
+                    if (rawTc.input !== undefined) {
+                        // Raw content block format — input is already an object
+                        input = typeof rawTc.input === 'string' ? JSON.parse(rawTc.input) : rawTc.input;
+                    }
+                    else if (tc.arguments !== undefined) {
+                        // NeutralToolCall format — arguments is a JSON string
+                        input = typeof tc.arguments === 'string' ? JSON.parse(tc.arguments) : (tc.arguments ?? {});
+                    }
+                    else {
+                        input = {};
+                    }
+                    content.push({
+                        type: 'tool_use',
+                        id: tc.id,
+                        name: tc.name,
+                        input,
+                    });
+                }
+            }
+            result.push({
+                role: 'assistant',
+                content: content.length === 1 && typeof content[0] === 'object' && content[0].type === 'text'
+                    ? msg.textContent || ''
+                    : content,
+            });
+            continue;
+        }
+        if (msg.role === 'user') {
+            // Tool results go as user messages with tool_result content blocks
+            if (msg.toolResults && msg.toolResults.length > 0) {
+                const content = [];
+                for (const tr of msg.toolResults) {
+                    content.push({
+                        type: 'tool_result',
+                        tool_use_id: tr.callId,
+                        content: tr.content,
+                        is_error: tr.isError || false,
+                    });
+                }
+                result.push({ role: 'user', content });
+            }
+            else {
+                result.push({ role: 'user', content: msg.textContent || '' });
+            }
+            continue;
+        }
+    }
+    return result;
+}
+/**
+ * Convert neutral messages to OpenAI Chat Completions API format.
+ */
+function toOpenAI(messages) {
+    const result = [];
+    for (const msg of messages) {
+        if (msg.role === 'system') {
+            result.push({ role: 'system', content: msg.textContent || '' });
+            continue;
+        }
+        if (msg.role === 'assistant') {
+            const providerMsg = {
+                role: 'assistant',
+                content: msg.textContent || null,
+            };
+            if (msg.toolCalls && msg.toolCalls.length > 0) {
+                providerMsg.tool_calls = msg.toolCalls.map(tc => {
+                    // Handle both NeutralToolCall { arguments: string } and raw content block { input: object }
+                    const rawTc = tc;
+                    let args;
+                    if (rawTc.input !== undefined) {
+                        args = typeof rawTc.input === 'string' ? rawTc.input : JSON.stringify(rawTc.input);
+                    }
+                    else if (tc.arguments !== undefined) {
+                        args = typeof tc.arguments === 'string' ? tc.arguments : JSON.stringify(tc.arguments);
+                    }
+                    else {
+                        args = '{}';
+                    }
+                    return {
+                        id: tc.id,
+                        type: 'function',
+                        function: {
+                            name: tc.name,
+                            arguments: args,
+                        },
+                    };
+                });
+            }
+            result.push(providerMsg);
+            continue;
+        }
+        if (msg.role === 'user') {
+            if (msg.toolResults && msg.toolResults.length > 0) {
+                // OpenAI tool results are separate "tool" role messages
+                for (const tr of msg.toolResults) {
+                    result.push({
+                        role: 'tool',
+                        tool_call_id: tr.callId,
+                        content: tr.content,
+                    });
+                }
+            }
+            else {
+                result.push({ role: 'user', content: msg.textContent || '' });
+            }
+            continue;
+        }
+    }
+    return result;
+}
+/**
+ * Convert neutral messages to OpenAI Responses API format.
+ */
+function toOpenAIResponses(messages) {
+    // Responses API uses a different item format
+    // For now, use the same as Chat Completions — the gateway handles the conversion
+    // This is a stub for when we need direct Responses API support
+    return toOpenAI(messages);
+}
+/**
+ * Convert neutral messages to provider-specific format.
+ */
+export function toProviderFormat(messages, provider) {
+    const providerType = detectProvider(provider);
+    switch (providerType) {
+        case 'anthropic':
+            return toAnthropic(messages);
+        case 'openai':
+            return toOpenAI(messages);
+        case 'openai-responses':
+            return toOpenAIResponses(messages);
+        default:
+            // Default to OpenAI format as it's most widely compatible
+            return toOpenAI(messages);
+    }
+}
+// ─── From Provider Format ────────────────────────────────────────
+/**
+ * Convert an Anthropic response to neutral format.
+ */
+function fromAnthropic(response) {
+    const content = response.content;
+    let textContent = null;
+    let toolCalls = null;
+    if (typeof content === 'string') {
+        textContent = content;
+    }
+    else if (Array.isArray(content)) {
+        const textParts = [];
+        const tools = [];
+        for (const block of content) {
+            if (block.type === 'text') {
+                textParts.push(block.text);
+            }
+            else if (block.type === 'tool_use') {
+                tools.push({
+                    id: normalizeToolCallId(block.id),
+                    name: block.name,
+                    arguments: JSON.stringify(block.input),
+                });
+            }
+        }
+        if (textParts.length > 0)
+            textContent = textParts.join('\n');
+        if (tools.length > 0)
+            toolCalls = tools;
+    }
+    return {
+        role: 'assistant',
+        textContent,
+        toolCalls,
+        toolResults: null,
+        metadata: {
+            originalProvider: 'anthropic',
+            stopReason: response.stop_reason,
+            model: response.model,
+        },
+    };
+}
+/**
+ * Convert an OpenAI response choice to neutral format.
+ */
+function fromOpenAI(choice) {
+    const message = choice.message
+        || choice;
+    const textContent = message.content || null;
+    let toolCalls = null;
+    const rawToolCalls = message.tool_calls;
+    if (rawToolCalls && rawToolCalls.length > 0) {
+        toolCalls = rawToolCalls.map(tc => ({
+            id: normalizeToolCallId(tc.id),
+            name: tc.function.name,
+            arguments: tc.function.arguments,
+        }));
+    }
+    return {
+        role: 'assistant',
+        textContent,
+        toolCalls,
+        toolResults: null,
+        metadata: {
+            originalProvider: 'openai',
+            finishReason: message.finish_reason || choice.finish_reason,
+        },
+    };
+}
+/**
+ * Convert a provider-specific response to neutral format.
+ */
+export function fromProviderFormat(response, provider) {
+    const providerType = detectProvider(provider);
+    switch (providerType) {
+        case 'anthropic':
+            return fromAnthropic(response);
+        case 'openai':
+        case 'openai-responses':
+            return fromOpenAI(response);
+        default:
+            return fromOpenAI(response);
+    }
+}
+/**
+ * Convert a user message (from chat input) to neutral format.
+ */
+export function userMessageToNeutral(content, metadata) {
+    return {
+        role: 'user',
+        textContent: content,
+        toolCalls: null,
+        toolResults: null,
+        metadata,
+    };
+}
+/**
+ * Convert tool results to a neutral user message.
+ */
+export function toolResultsToNeutral(results) {
+    return {
+        role: 'user',
+        textContent: null,
+        toolCalls: null,
+        toolResults: results,
+    };
+}
+//# sourceMappingURL=provider-translator.js.map

package/dist/rate-limiter.d.ts

@@ -0,0 +1,76 @@
+/**
+ * HyperMem Rate Limiter
+ *
+ * Token-bucket rate limiter for embedding API calls.
+ * Prevents hammering Ollama during bulk indexing.
+ *
+ * Strategy:
+ *   - Burst: allow immediate calls up to bucket capacity
+ *   - Sustained: refill tokens at a steady rate
+ *   - Backpressure: when tokens exhausted, delay until available
+ *   - Priority: high-priority requests (user-facing recall) get reserved tokens
+ *
+ * Usage:
+ *   const limiter = new RateLimiter({ tokensPerSecond: 5, burstSize: 10 });
+ *   await limiter.acquire();  // Waits if necessary
+ *   const embeddings = await generateEmbeddings(texts);
+ */
+export interface RateLimiterConfig {
+    /** Tokens refilled per second. Default: 5 */
+    tokensPerSecond: number;
+    /** Maximum burst capacity. Default: 10 */
+    burstSize: number;
+    /** Reserved tokens for high-priority requests. Default: 2 */
+    reservedHigh: number;
+    /** Maximum wait time before rejecting (ms). Default: 30000 (30s) */
+    maxWaitMs: number;
+}
+export type Priority = 'high' | 'normal' | 'low';
+export declare class RateLimiter {
+    private tokens;
+    private lastRefill;
+    private readonly config;
+    private waitQueue;
+    private refillTimer;
+    private _totalAcquired;
+    private _totalWaited;
+    private _totalRejected;
+    constructor(config?: Partial<RateLimiterConfig>);
+    /**
+     * Acquire tokens. Blocks until tokens are available or maxWaitMs expires.
+     *
+     * @param count - Number of tokens to acquire (default 1)
+     * @param priority - Request priority (high gets reserved tokens)
+     * @throws Error if wait exceeds maxWaitMs
+     */
+    acquire(count?: number, priority?: Priority): Promise<void>;
+    /**
+     * Try to acquire tokens without waiting.
+     * Returns true if tokens were acquired, false if not.
+     */
+    tryAcquire(count?: number, priority?: Priority): boolean;
+    /**
+     * Get current limiter state.
+     */
+    get state(): {
+        availableTokens: number;
+        pendingRequests: number;
+        stats: {
+            acquired: number;
+            waited: number;
+            rejected: number;
+        };
+    };
+    /**
+     * Stop the refill timer.
+     */
+    destroy(): void;
+    private refill;
+    private processQueue;
+}
+/**
+ * Rate-limited embedding generator.
+ * Wraps generateEmbeddings with rate limiting.
+ */
+export declare function createRateLimitedEmbedder(embedFn: (texts: string[]) => Promise<Float32Array[]>, limiter: RateLimiter): (texts: string[], priority?: Priority) => Promise<Float32Array[]>;
+//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/rate-limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limiter.d.ts","sourceRoot":"","sources":["../src/rate-limiter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,iBAAiB;IAChC,6CAA6C;IAC7C,eAAe,EAAE,MAAM,CAAC;IACxB,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,YAAY,EAAE,MAAM,CAAC;IACrB,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AASjD,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;IAC3C,OAAO,CAAC,SAAS,CAMT;IACR,OAAO,CAAC,WAAW,CAA+C;IAClE,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,cAAc,CAAK;gBAEf,MAAM,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC;IAS/C;;;;;;OAMG;IACG,OAAO,CAAC,KAAK,GAAE,MAAU,EAAE,QAAQ,GAAE,QAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqC9E;;;OAGG;IACH,UAAU,CAAC,KAAK,GAAE,MAAU,EAAE,QAAQ,GAAE,QAAmB,GAAG,OAAO;IAgBrE;;OAEG;IACH,IAAI,KAAK,IAAI;QACX,eAAe,EAAE,MAAM,CAAC;QACxB,eAAe,EAAE,MAAM,CAAC;QACxB,KAAK,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;KAC/D,CAWA;IAED;;OAEG;IACH,OAAO,IAAI,IAAI;IAcf,OAAO,CAAC,MAAM;IAcd,OAAO,CAAC,YAAY;CAiCrB;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,EACrD,OAAO,EAAE,WAAW,GACnB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,QAAQ,CAAC,EAAE,QAAQ,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,CASnE"}