@revealui/ai 0.1.0

package/dist/memory/stores/working-memory.js

@@ -0,0 +1,336 @@
+/**
+ * Working Memory
+ *
+ * Short-term, session-scoped memory for AI agents.
+ * Uses CRDTs for conflict-free state management across distributed nodes.
+ *
+ * - Context: LWWRegister for single-valued state (last writer wins)
+ * - Active Agents: ORSet for collection of active agent configurations
+ * - Session State: LWWRegister for session metadata
+ */
+import { LWWRegister } from '../crdt/lww-register.js';
+import { ORSet } from '../crdt/or-set.js';
+import { deepClone } from '../utils/deep-clone.js';
+// =============================================================================
+// Working Memory
+// =============================================================================
+/**
+ * Working Memory for session-scoped agent state.
+ *
+ * @example
+ * ```typescript
+ * const memory = new WorkingMemory('session-123', 'node-abc')
+ * await memory.load()
+ *
+ * memory.setContext({ userId: 'user-1', theme: 'dark' })
+ * const agentTag = memory.addAgent(agentConfig)
+ * memory.updateSessionState({ status: 'active' })
+ *
+ * await memory.save()
+ * ```
+ */
+export class WorkingMemory {
+    context;
+    sessionState;
+    activeAgents;
+    sessionId;
+    nodeId;
+    persistence;
+    /**
+     * Creates a new WorkingMemory instance.
+     *
+     * @param sessionId - Unique session identifier
+     * @param nodeId - Unique node identifier (for CRDT operations)
+     * @param persistence - Optional persistence adapter
+     */
+    constructor(sessionId, nodeId, persistence) {
+        this.sessionId = sessionId;
+        this.nodeId = nodeId;
+        this.persistence = persistence;
+        // Initialize CRDTs
+        this.context = new LWWRegister(nodeId, {});
+        this.sessionState = new LWWRegister(nodeId, {
+            status: 'active',
+        });
+        this.activeAgents = new ORSet(nodeId);
+    }
+    /**
+     * Sets the entire context object.
+     *
+     * @param context - Context data to set
+     */
+    /**
+     * Sets the entire context object.
+     *
+     * **Performance Note**: This replaces the entire context. For partial updates,
+     * use `updateContext()` or `setContextValue()`.
+     *
+     * **Validation**: The context is validated by LWWRegister (which clones values),
+     * but for additional security, consider validating before calling this method.
+     *
+     * @param context - The complete context object
+     */
+    setContext(context) {
+        this.context.set(context);
+    }
+    /**
+     * Gets the current context.
+     *
+     * @returns Current context object
+     */
+    getContext() {
+        return this.context.get();
+    }
+    /**
+     * Updates context with partial data.
+     * Merges with existing context.
+     *
+     * @param updates - Partial context updates
+     */
+    updateContext(updates) {
+        const current = this.context.get();
+        this.context.set({
+            ...current,
+            ...updates,
+        });
+    }
+    /**
+     * Gets a specific context value.
+     *
+     * @param key - Context key
+     * @returns Context value or undefined
+     */
+    /**
+     * Gets a specific context value by key.
+     *
+     * **Immutability Guarantee**: Returns a deep clone of object/array values to prevent external mutations.
+     * Primitives (strings, numbers, booleans, null) are returned as-is.
+     *
+     * @param key - The context key to retrieve
+     * @returns The context value (cloned if object/array, direct reference if primitive)
+     */
+    getContextValue(key) {
+        const context = this.context.get(); // Already cloned by LWWRegister.get()
+        const value = context[key];
+        // Explicitly clone the value for clarity and to ensure immutability
+        // Note: This may result in double cloning (context is already cloned),
+        // but it makes the API contract explicit and safe
+        if (value !== null && typeof value === 'object') {
+            return deepClone(value);
+        }
+        return value;
+    }
+    /**
+     * Sets a specific context value.
+     *
+     * **Performance Note**: This method clones the entire context object to update
+     * a single key. For multiple updates, use `updateContext()` instead.
+     *
+     * @param key - Context key
+     * @param value - Context value
+     */
+    setContextValue(key, value) {
+        const current = this.context.get();
+        this.context.set({
+            ...current,
+            [key]: value,
+        });
+    }
+    /**
+     * Adds an agent to the active agents set.
+     *
+     * @param agent - Agent configuration
+     * @returns Unique tag for this agent addition
+     */
+    addAgent(agent) {
+        return this.activeAgents.add(agent);
+    }
+    /**
+     * Removes an agent by tag.
+     *
+     * @param tag - Tag returned from addAgent
+     * @returns true if agent was removed
+     */
+    removeAgent(tag) {
+        return this.activeAgents.remove(tag);
+    }
+    /**
+     * Removes an agent by ID (removes all instances).
+     *
+     * @param agentId - Agent ID to remove
+     * @returns Number of instances removed
+     */
+    removeAgentById(agentId) {
+        const agents = this.activeAgents.values();
+        let count = 0;
+        for (const agent of agents) {
+            if (agent.id === agentId) {
+                const entries = this.activeAgents.entries();
+                for (const [tag, agentValue] of entries) {
+                    if (agentValue.id === agentId) {
+                        this.activeAgents.remove(tag);
+                        count++;
+                    }
+                }
+                break;
+            }
+        }
+        return count;
+    }
+    /**
+     * Gets all active agents.
+     *
+     * @returns Array of active agent configurations
+     */
+    getActiveAgents() {
+        return this.activeAgents.values();
+    }
+    /**
+     * Checks if an agent is active.
+     *
+     * @param agentId - Agent ID to check
+     * @returns true if agent is active
+     */
+    hasAgent(agentId) {
+        return this.activeAgents.values().some((agent) => agent.id === agentId);
+    }
+    /**
+     * Updates session state with partial data.
+     *
+     * @param state - Partial session state
+     */
+    updateSessionState(state) {
+        const current = this.sessionState.get();
+        this.sessionState.set({
+            ...current,
+            ...state,
+        });
+    }
+    /**
+     * Gets the current session state.
+     *
+     * @returns Current session state
+     */
+    getSessionState() {
+        return this.sessionState.get();
+    }
+    /**
+     * Merges another WorkingMemory into this one.
+     * Uses CRDT merge operations for conflict resolution.
+     *
+     * @param other - WorkingMemory to merge
+     * @returns New merged WorkingMemory
+     */
+    merge(other) {
+        const merged = new WorkingMemory(this.sessionId, this.nodeId, this.persistence);
+        // Merge CRDTs
+        merged.context = this.context.merge(other.context);
+        merged.sessionState = this.sessionState.merge(other.sessionState);
+        merged.activeAgents = this.activeAgents.merge(other.activeAgents);
+        return merged;
+    }
+    /**
+     * Loads state from database.
+     *
+     * @throws Error if persistence is not configured
+     */
+    async load() {
+        if (!this.persistence) {
+            throw new Error('Persistence not configured. Pass persistence to constructor.');
+        }
+        const crdtId = `working-memory:${this.sessionId}`;
+        const states = await this.persistence.loadCompositeState(crdtId);
+        // Restore context
+        const contextData = states.get('lww_register:context');
+        if (contextData && 'value' in contextData) {
+            const contextReg = LWWRegister.fromData(contextData);
+            this.context = contextReg;
+        }
+        // Restore session state
+        const sessionStateData = states.get('lww_register:sessionState');
+        if (sessionStateData && 'value' in sessionStateData) {
+            const sessionStateReg = LWWRegister.fromData(sessionStateData);
+            this.sessionState = sessionStateReg;
+        }
+        // Restore active agents
+        const agentsData = states.get('or_set:activeAgents');
+        if (agentsData && 'added' in agentsData) {
+            const agentsSet = ORSet.fromData(agentsData);
+            this.activeAgents = agentsSet;
+        }
+    }
+    /**
+     * Saves state to database.
+     *
+     * @throws Error if persistence is not configured
+     */
+    async save() {
+        if (!this.persistence) {
+            throw new Error('Persistence not configured. Pass persistence to constructor.');
+        }
+        const crdtId = `working-memory:${this.sessionId}`;
+        const states = new Map();
+        // Save all CRDTs with composite keys
+        states.set('lww_register:context', this.context.toData());
+        states.set('lww_register:sessionState', this.sessionState.toData());
+        states.set('or_set:activeAgents', this.activeAgents.toData());
+        await this.persistence.saveCompositeState(crdtId, states);
+    }
+    /**
+     * Serializes WorkingMemory to plain object.
+     *
+     * @returns Serialized data
+     */
+    toData() {
+        return {
+            sessionId: this.sessionId,
+            nodeId: this.nodeId,
+            context: this.context.toData(),
+            sessionState: this.sessionState.toData(),
+            activeAgents: this.activeAgents.toData(),
+        };
+    }
+    /**
+     * Deserializes WorkingMemory from plain object.
+     *
+     * @param data - Serialized data
+     * @param persistence - Optional persistence adapter
+     * @returns New WorkingMemory instance
+     */
+    static fromData(data, persistence) {
+        const memory = new WorkingMemory(data.sessionId, data.nodeId, persistence);
+        memory.context = LWWRegister.fromData(data.context);
+        memory.sessionState = LWWRegister.fromData(data.sessionState);
+        memory.activeAgents = ORSet.fromData(data.activeAgents);
+        return memory;
+    }
+    /**
+     * Creates a copy of this WorkingMemory.
+     *
+     * @returns New WorkingMemory with same state
+     */
+    clone() {
+        return WorkingMemory.fromData(this.toData(), this.persistence);
+    }
+    /**
+     * Gets the session ID.
+     */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /**
+     * Gets the node ID.
+     */
+    getNodeId() {
+        return this.nodeId;
+    }
+    /**
+     * Gets the context register's timestamp.
+     * Used for proper CRDT merge semantics.
+     *
+     * @returns Timestamp of the last context update
+     */
+    getContextTimestamp() {
+        return this.context.getTimestamp();
+    }
+}

package/dist/memory/utils/deep-clone.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Deep Clone Utility
+ *
+ * @deprecated This file has been moved to @revealui/core/utils/deep-clone.ts
+ * Re-exporting from core for backward compatibility during migration.
+ *
+ * Import directly from '@revealui/core/utils/deep-clone' instead.
+ */
+export { deepClone } from '@revealui/core/utils/deep-clone';
+//# sourceMappingURL=deep-clone.d.ts.map

package/dist/memory/utils/deep-clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-clone.d.ts","sourceRoot":"","sources":["../../../src/memory/utils/deep-clone.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA"}

package/dist/memory/utils/deep-clone.js

@@ -0,0 +1,9 @@
+/**
+ * Deep Clone Utility
+ *
+ * @deprecated This file has been moved to @revealui/core/utils/deep-clone.ts
+ * Re-exporting from core for backward compatibility during migration.
+ *
+ * Import directly from '@revealui/core/utils/deep-clone' instead.
+ */
+export { deepClone } from '@revealui/core/utils/deep-clone';

package/dist/memory/utils/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Utility functions
+ */
+export { deepClone } from './deep-clone.js';
+export { createLogger, defaultLogger, type Logger } from './logger.js';
+export { findAgentContextById, findAgentMemoriesByUserId, findAgentMemoryById, findNodeIdMappingByEntity, findNodeIdMappingByHash, findUserById, } from './sql-helpers.js';
+export { estimateObjectSize, hasCircularReference, validateContext, validateContextKey, validateContextSize, validateContextValue, validateObjectDepth, } from './validation.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/memory/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/memory/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAA;AACtE,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EACnB,yBAAyB,EACzB,uBAAuB,EACvB,YAAY,GACb,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,iBAAiB,CAAA"}

package/dist/memory/utils/index.js

@@ -0,0 +1,7 @@
+/**
+ * Utility functions
+ */
+export { deepClone } from './deep-clone.js';
+export { createLogger, defaultLogger } from './logger.js';
+export { findAgentContextById, findAgentMemoriesByUserId, findAgentMemoryById, findNodeIdMappingByEntity, findNodeIdMappingByHash, findUserById, } from './sql-helpers.js';
+export { estimateObjectSize, hasCircularReference, validateContext, validateContextKey, validateContextSize, validateContextValue, validateObjectDepth, } from './validation.js';

package/dist/memory/utils/logger.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Simple Logger Utility
+ *
+ * Provides a minimal logging interface that can be easily replaced
+ * with a proper logging service later. Respects environment and log levels.
+ */
+export interface Logger {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+}
+/**
+ * Creates a logger instance with optional prefix
+ */
+export declare function createLogger(prefix?: string): Logger;
+/**
+ * Default logger instance
+ */
+export declare const defaultLogger: Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/memory/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/memory/utils/logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAA;IAClC,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAA;IAClC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAA;IACnC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAA;CACpC;AA0DD;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,MAAqC,CAAA"}

package/dist/memory/utils/logger.js

@@ -0,0 +1,62 @@
+/**
+ * Simple Logger Utility
+ *
+ * Provides a minimal logging interface that can be easily replaced
+ * with a proper logging service later. Respects environment and log levels.
+ */
+/**
+ * Environment-aware logger implementation
+ * Only logs when appropriate for the environment and log level
+ */
+class SimpleLogger {
+    prefix;
+    minLevel;
+    isProduction;
+    constructor(prefix = '[Memory]') {
+        this.prefix = prefix;
+        this.isProduction = process.env.NODE_ENV === 'production';
+        this.minLevel = process.env.LOG_LEVEL || (this.isProduction ? 'warn' : 'debug');
+    }
+    shouldLog(level) {
+        // Never log debug or info in production
+        if (this.isProduction && (level === 'debug' || level === 'info')) {
+            return false;
+        }
+        const levels = ['debug', 'info', 'warn', 'error'];
+        return levels.indexOf(level) >= levels.indexOf(this.minLevel);
+    }
+    info(...args) {
+        // Info logs are never shown in production
+        if (process.env.NODE_ENV !== 'production') {
+            console.log(this.prefix, ...args);
+        }
+        // In production: complete no-op
+    }
+    warn(...args) {
+        // Warning logs are never shown in production
+        if (process.env.NODE_ENV !== 'production') {
+            console.warn(this.prefix, ...args);
+        }
+        // In production: complete no-op
+    }
+    error(...args) {
+        if (this.shouldLog('error')) {
+            console.error(this.prefix, ...args);
+        }
+    }
+    debug(...args) {
+        if (process.env.NODE_ENV !== 'production') {
+            console.debug(this.prefix, ...args);
+        }
+    }
+}
+/**
+ * Creates a logger instance with optional prefix
+ */
+export function createLogger(prefix) {
+    return new SimpleLogger(prefix);
+}
+/**
+ * Default logger instance
+ */
+export const defaultLogger = new SimpleLogger('[Memory]');

package/dist/memory/utils/sql-helpers.d.ts

@@ -0,0 +1,97 @@
+/**
+ * SQL Helper Utilities
+ *
+ * Provides type-safe raw SQL query helpers to work around Neon HTTP driver
+ * compatibility issues with Drizzle's relational query builder.
+ *
+ * These helpers use Drizzle's sql tagged template for type safety and
+ * SQL injection prevention.
+ */
+import type { AgentMemory } from '@revealui/contracts/agents';
+import type { NodeIdMappingsRow } from '@revealui/contracts/generated';
+import type { Database } from '@revealui/db/client';
+/**
+ * Finds a node ID mapping by hash (primary key).
+ *
+ * @param db - Database client
+ * @param hash - SHA-256 hash of entity ID
+ * @returns Node ID mapping or undefined if not found
+ */
+export declare function findNodeIdMappingByHash(db: Database, hash: string): Promise<NodeIdMappingsRow | undefined>;
+/**
+ * Finds a node ID mapping by entity ID and type.
+ *
+ * @param db - Database client
+ * @param entityType - Type of entity ('session' or 'user')
+ * @param entityId - Entity identifier
+ * @returns Node ID mapping or undefined if not found
+ */
+export declare function findNodeIdMappingByEntity(db: Database, entityType: 'session' | 'user', entityId: string): Promise<NodeIdMappingsRow | undefined>;
+/**
+ * Finds an agent memory by ID (returns raw database record format).
+ *
+ * @deprecated Use VectorMemoryService.getById() instead. This function queries
+ * agent_memories which is now in the vector database (Supabase), not REST database.
+ * If you need to query memories, use VectorMemoryService which uses the correct database.
+ *
+ * @param db - Database client (NOTE: Should be vector client, but type doesn't enforce this)
+ * @param memoryId - Memory identifier
+ * @returns Raw database memory record or undefined if not found
+ */
+export declare function findAgentMemoryById(db: Database, memoryId: string): Promise<{
+    id: string;
+    version: number;
+    content: string;
+    type: string;
+    source: unknown;
+    embedding: number[] | null;
+    embeddingMetadata: unknown;
+    metadata: unknown;
+    accessCount: number | null;
+    accessedAt: Date | null;
+    verified: boolean | null;
+    createdAt: Date;
+    expiresAt: Date | null;
+} | undefined>;
+/**
+ * Finds agent memories by user ID.
+ *
+ * @deprecated Use VectorMemoryService.searchSimilar() or VectorMemoryService with filters instead.
+ * This function queries agent_memories which is now in the vector database (Supabase).
+ * If you need to query memories, use VectorMemoryService which uses the correct database.
+ *
+ * @param db - Database client (NOTE: Should be vector client, but type doesn't enforce this)
+ * @param userId - User identifier
+ * @returns Array of agent memories
+ */
+export declare function findAgentMemoriesByUserId(db: Database, userId: string): Promise<AgentMemory[]>;
+/**
+ * Finds an agent context by CRDT ID (returns raw database record format).
+ *
+ * @param db - Database client
+ * @param crdtId - CRDT identifier (format: sessionId:agentId)
+ * @returns Raw database context record or undefined if not found
+ */
+export declare function findAgentContextById(db: Database, crdtId: string): Promise<{
+    id: string;
+    version: number;
+    sessionId: string;
+    agentId: string;
+    context: unknown;
+    priority: number | null;
+    embedding: number[] | null;
+    createdAt: Date;
+    updatedAt: Date;
+} | undefined>;
+/**
+ * Finds a user by ID.
+ *
+ * @param db - Database client
+ * @param userId - User identifier
+ * @returns User record or undefined if not found
+ */
+export declare function findUserById(db: Database, userId: string): Promise<{
+    id: string;
+    preferences: unknown;
+} | undefined>;
+//# sourceMappingURL=sql-helpers.d.ts.map

package/dist/memory/utils/sql-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-helpers.d.ts","sourceRoot":"","sources":["../../../src/memory/utils/sql-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAmDnD;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,QAAQ,EACZ,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CA8BxC;AAED;;;;;;;GAOG;AACH,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,QAAQ,EACZ,UAAU,EAAE,SAAS,GAAG,MAAM,EAC9B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CA6BxC;AAMD;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,QAAQ,EACZ,QAAQ,EAAE,MAAM,GACf,OAAO,CACN;IACE,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,OAAO,CAAA;IACf,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;IAC1B,iBAAiB,EAAE,OAAO,CAAA;IAC1B,QAAQ,EAAE,OAAO,CAAA;IACjB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,UAAU,EAAE,IAAI,GAAG,IAAI,CAAA;IACvB,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAA;IACxB,SAAS,EAAE,IAAI,CAAA;IACf,SAAS,EAAE,IAAI,GAAG,IAAI,CAAA;CACvB,GACD,SAAS,CACZ,CA+BA;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,QAAQ,EACZ,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,WAAW,EAAE,CAAC,CAoCxB;AAMD;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,QAAQ,EACZ,MAAM,EAAE,MAAM,GACb,OAAO,CACN;IACE,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;IAC1B,SAAS,EAAE,IAAI,CAAA;IACf,SAAS,EAAE,IAAI,CAAA;CAChB,GACD,SAAS,CACZ,CAwBA;AAMD;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,EAAE,EAAE,QAAQ,EACZ,MAAM,EAAE,MAAM,GACb,OAAO,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,CAAC,CAU3D"}