@revealui/ai 0.1.0

package/dist/memory/agent/context-manager.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Agent Context Manager
+ *
+ * Wraps WorkingMemory for agent context management.
+ * Provides a higher-level API for managing agent contexts with CRDT support.
+ */
+import type { Database } from '@revealui/db/client';
+import type { CRDTPersistence } from '../persistence/crdt-persistence.js';
+import { WorkingMemory } from '../stores/working-memory.js';
+/**
+ * Manages agent context with CRDT support.
+ *
+ * @example
+ * ```typescript
+ * const manager = new AgentContextManager('session-123', 'agent-456', 'node-abc', db, persistence)
+ * await manager.sync()
+ *
+ * await manager.setContext('theme', 'dark')
+ * const theme = manager.getContext('theme')
+ *
+ * await manager.save()
+ * ```
+ */
+export declare class AgentContextManager {
+    private workingMemory;
+    private sessionId;
+    private agentId;
+    private nodeId;
+    private db;
+    /**
+     * Creates a new AgentContextManager.
+     *
+     * @param sessionId - Session identifier
+     * @param agentId - Agent identifier
+     * @param nodeId - Node identifier (for CRDT operations)
+     * @param db - Database client
+     * @param persistence - Optional persistence adapter
+     */
+    constructor(sessionId: string, agentId: string, nodeId: string, db: Database, persistence?: CRDTPersistence);
+    /**
+     * Sets a context value.
+     *
+     * @param key - Context key
+     * @param value - Context value
+     */
+    /**
+     * Sets a context key-value pair.
+     *
+     * **Validation**: Validates key and value before setting to prevent security issues.
+     *
+     * @param key - The context key
+     * @param value - The context value
+     * @throws ValidationError if key or value is invalid
+     */
+    setContext(key: string, value: unknown): void;
+    /**
+     * Gets a context value.
+     *
+     * @param key - Context key
+     * @returns Context value or undefined
+     */
+    getContext(key: string): unknown;
+    /**
+     * Gets all context.
+     *
+     * @returns Context object
+     */
+    getAllContext(): Record<string, unknown>;
+    /**
+     * Sets entire context object.
+     *
+     * @param context - Context object
+     */
+    setAllContext(context: Record<string, unknown>): void;
+    /**
+     * Updates context with partial data.
+     *
+     * @param updates - Partial context updates
+     */
+    /**
+     * Updates multiple context keys at once.
+     *
+     * **Validation**: Validates all keys and values before updating.
+     *
+     * @param updates - Object with key-value pairs to update
+     * @throws ValidationError if any key or value is invalid
+     */
+    updateContext(updates: Partial<Record<string, unknown>>): void;
+    /**
+     * Merges context from another source (for syncing with remote state).
+     * Uses CRDT merge for conflict resolution at the key level.
+     *
+     * Note: Since LWWRegister works at the object level, we merge the context
+     * objects manually to preserve non-conflicting keys from both sides.
+     * For conflicting keys, we use LWW semantics with proper timestamps.
+     *
+     * IMPORTANT: Nested objects are merged at the top level only. If both local
+     * and remote have the same key with object values, the entire object is
+     * replaced (LWW semantics), not deep-merged. For example:
+     * - Local: { user: { name: 'Alice', age: 30 } }
+     * - Remote: { user: { name: 'Bob', city: 'NYC' } }
+     * - Result: { user: { name: 'Bob', city: 'NYC' } } (remote wins, age is lost)
+     *
+     * @param remoteContext - Context to merge from (must be a plain object)
+     * @throws ValidationError if remoteContext is not a valid object
+     */
+    mergeContext(remoteContext: Record<string, unknown>): Promise<void>;
+    /**
+     * Removes a context key.
+     *
+     * @param key - Context key to remove
+     */
+    removeContext(key: string): void;
+    /**
+     * Syncs with database.
+     * Loads existing context, merges with local state, saves back.
+     *
+     * @throws Error if persistence is not configured
+     */
+    sync(): Promise<void>;
+    /**
+     * Saves context to database.
+     *
+     * @throws Error if persistence is not configured
+     */
+    save(): Promise<void>;
+    /**
+     * Loads context from database.
+     *
+     * @throws Error if persistence is not configured
+     */
+    load(): Promise<void>;
+    /**
+     * Gets the underlying WorkingMemory instance.
+     *
+     * @returns WorkingMemory instance
+     */
+    getWorkingMemory(): WorkingMemory;
+    /**
+     * Gets session ID.
+     */
+    getSessionId(): string;
+    /**
+     * Gets agent ID.
+     */
+    getAgentId(): string;
+}
+//# sourceMappingURL=context-manager.d.ts.map

package/dist/memory/agent/context-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-manager.d.ts","sourceRoot":"","sources":["../../../src/memory/agent/context-manager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAGnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAA;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAA;AAa3D;;;;;;;;;;;;;GAaG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,EAAE,CAAU;IAEpB;;;;;;;;OAQG;gBAED,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,QAAQ,EACZ,WAAW,CAAC,EAAE,eAAe;IAS/B;;;;;OAKG;IACH;;;;;;;;OAQG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAM7C;;;;;OAKG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhC;;;;OAIG;IACH,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAIxC;;;;OAIG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAIrD;;;;OAIG;IACH;;;;;;;OAOG;IACH,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI;IAe9D;;;;;;;;;;;;;;;;;OAiBG;IACG,YAAY,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IA6FzE;;;;OAIG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAOhC;;;;;OAKG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA+B3B;;;;OAIG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;;;OAIG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;;;OAIG;IACH,gBAAgB,IAAI,aAAa;IAIjC;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,UAAU,IAAI,MAAM;CAGrB"}

package/dist/memory/agent/context-manager.js

@@ -0,0 +1,284 @@
+/**
+ * Agent Context Manager
+ *
+ * Wraps WorkingMemory for agent context management.
+ * Provides a higher-level API for managing agent contexts with CRDT support.
+ */
+import { LWWRegister } from '../crdt/lww-register.js';
+import { MemoryError, MigrationError, ValidationError } from '../errors/index.js';
+import { WorkingMemory } from '../stores/working-memory.js';
+import { findAgentContextById } from '../utils/sql-helpers.js';
+import { hasCircularReference, validateContext, validateContextKey, validateContextValue, } from '../utils/validation.js';
+// =============================================================================
+// Agent Context Manager
+// =============================================================================
+/**
+ * Manages agent context with CRDT support.
+ *
+ * @example
+ * ```typescript
+ * const manager = new AgentContextManager('session-123', 'agent-456', 'node-abc', db, persistence)
+ * await manager.sync()
+ *
+ * await manager.setContext('theme', 'dark')
+ * const theme = manager.getContext('theme')
+ *
+ * await manager.save()
+ * ```
+ */
+export class AgentContextManager {
+    workingMemory;
+    sessionId;
+    agentId;
+    nodeId;
+    db;
+    /**
+     * Creates a new AgentContextManager.
+     *
+     * @param sessionId - Session identifier
+     * @param agentId - Agent identifier
+     * @param nodeId - Node identifier (for CRDT operations)
+     * @param db - Database client
+     * @param persistence - Optional persistence adapter
+     */
+    constructor(sessionId, agentId, nodeId, db, persistence) {
+        this.sessionId = sessionId;
+        this.agentId = agentId;
+        this.nodeId = nodeId;
+        this.db = db;
+        this.workingMemory = new WorkingMemory(sessionId, nodeId, persistence);
+    }
+    /**
+     * Sets a context value.
+     *
+     * @param key - Context key
+     * @param value - Context value
+     */
+    /**
+     * Sets a context key-value pair.
+     *
+     * **Validation**: Validates key and value before setting to prevent security issues.
+     *
+     * @param key - The context key
+     * @param value - The context value
+     * @throws ValidationError if key or value is invalid
+     */
+    setContext(key, value) {
+        validateContextKey(key);
+        validateContextValue(value, key);
+        this.workingMemory.setContextValue(key, value);
+    }
+    /**
+     * Gets a context value.
+     *
+     * @param key - Context key
+     * @returns Context value or undefined
+     */
+    getContext(key) {
+        return this.workingMemory.getContextValue(key);
+    }
+    /**
+     * Gets all context.
+     *
+     * @returns Context object
+     */
+    getAllContext() {
+        return this.workingMemory.getContext();
+    }
+    /**
+     * Sets entire context object.
+     *
+     * @param context - Context object
+     */
+    setAllContext(context) {
+        this.workingMemory.setContext(context);
+    }
+    /**
+     * Updates context with partial data.
+     *
+     * @param updates - Partial context updates
+     */
+    /**
+     * Updates multiple context keys at once.
+     *
+     * **Validation**: Validates all keys and values before updating.
+     *
+     * @param updates - Object with key-value pairs to update
+     * @throws ValidationError if any key or value is invalid
+     */
+    updateContext(updates) {
+        // Validate all keys and values before updating
+        for (const [key, value] of Object.entries(updates)) {
+            validateContextKey(key);
+            validateContextValue(value, key);
+        }
+        // Check for circular references in the updates object
+        if (hasCircularReference(updates)) {
+            throw new ValidationError('Updates object contains circular references');
+        }
+        this.workingMemory.updateContext(updates);
+    }
+    /**
+     * Merges context from another source (for syncing with remote state).
+     * Uses CRDT merge for conflict resolution at the key level.
+     *
+     * Note: Since LWWRegister works at the object level, we merge the context
+     * objects manually to preserve non-conflicting keys from both sides.
+     * For conflicting keys, we use LWW semantics with proper timestamps.
+     *
+     * IMPORTANT: Nested objects are merged at the top level only. If both local
+     * and remote have the same key with object values, the entire object is
+     * replaced (LWW semantics), not deep-merged. For example:
+     * - Local: { user: { name: 'Alice', age: 30 } }
+     * - Remote: { user: { name: 'Bob', city: 'NYC' } }
+     * - Result: { user: { name: 'Bob', city: 'NYC' } } (remote wins, age is lost)
+     *
+     * @param remoteContext - Context to merge from (must be a plain object)
+     * @throws ValidationError if remoteContext is not a valid object
+     */
+    async mergeContext(remoteContext) {
+        try {
+            // Validate input
+            if (!remoteContext || typeof remoteContext !== 'object' || Array.isArray(remoteContext)) {
+                throw new ValidationError(`remoteContext must be a plain object, got: ${typeof remoteContext}`);
+            }
+            // Early return for empty merge (no-op)
+            if (Object.keys(remoteContext).length === 0) {
+                return;
+            }
+            // Validate remote context (security and performance checks)
+            try {
+                validateContext(remoteContext);
+            }
+            catch (validationError) {
+                throw new ValidationError(`Invalid remote context: ${validationError instanceof Error ? validationError.message : String(validationError)}`);
+            }
+            // Check for circular references (deepClone will throw, but we want a better error)
+            if (hasCircularReference(remoteContext)) {
+                throw new ValidationError('Remote context contains circular references, which are not supported');
+            }
+            // Load current state
+            await this.workingMemory.load();
+            // Get current context and actual timestamp from the register
+            const currentContext = this.workingMemory.getContext();
+            const currentTimestamp = this.workingMemory.getContextTimestamp();
+            const now = Date.now();
+            // Ensure remote timestamp is always later than current to simulate remote update
+            // This ensures remote values win in conflicts (last-writer-wins semantics)
+            const remoteTimestamp = Math.max(currentTimestamp + 1, now);
+            // Merge objects at key level to preserve all non-conflicting keys
+            const mergedContext = { ...currentContext };
+            // Process each remote key
+            for (const [key, remoteValue] of Object.entries(remoteContext)) {
+                if (!(key in currentContext)) {
+                    // New key from remote - add it
+                    mergedContext[key] = remoteValue;
+                }
+                else {
+                    // Conflicting key - use LWWRegister to determine winner
+                    // Create temporary registers for this key with proper timestamps
+                    const currentValue = currentContext[key];
+                    // Current value uses the actual context register timestamp
+                    // This ensures proper CRDT semantics based on when the context was last updated
+                    const currentKeyReg = new LWWRegister(this.nodeId, currentValue, currentTimestamp);
+                    // Remote value gets a timestamp guaranteed to be later (simulating remote update)
+                    const remoteKeyReg = new LWWRegister(`${this.nodeId}-remote`, remoteValue, remoteTimestamp);
+                    // Merge to get winner (remote will always win due to later timestamp)
+                    const mergedKeyReg = currentKeyReg.merge(remoteKeyReg);
+                    mergedContext[key] = mergedKeyReg.get();
+                }
+            }
+            // Update context with merged values
+            // Note: setContext() will update the register's timestamp to the current time,
+            // which is correct for a merge operation (it represents a new local update
+            // that incorporates remote changes, so it should have a new timestamp)
+            this.workingMemory.setContext(mergedContext);
+            // Save merged state
+            await this.workingMemory.save();
+        }
+        catch (error) {
+            // Wrap errors with context for better debugging
+            if (error instanceof ValidationError || error instanceof MemoryError) {
+                throw error; // Re-throw known errors as-is
+            }
+            throw new MemoryError(`Failed to merge context: ${error instanceof Error ? error.message : String(error)}`, 'MERGE_ERROR', 500);
+        }
+    }
+    /**
+     * Removes a context key.
+     *
+     * @param key - Context key to remove
+     */
+    removeContext(key) {
+        const current = this.workingMemory.getContext();
+        const updated = { ...current };
+        Reflect.deleteProperty(updated, key);
+        this.workingMemory.setContext(updated);
+    }
+    /**
+     * Syncs with database.
+     * Loads existing context, merges with local state, saves back.
+     *
+     * @throws Error if persistence is not configured
+     */
+    async sync() {
+        const contextId = `${this.sessionId}:${this.agentId}`;
+        // Load existing context from database (using raw SQL for Neon HTTP compatibility)
+        const existing = await findAgentContextById(this.db, contextId);
+        if (existing) {
+            // Load WorkingMemory state
+            await this.workingMemory.load();
+            // Merge with existing context (if any non-CRDT context exists)
+            const existingContext = existing.context || {};
+            const crdtData = existingContext._crdt;
+            // If there's non-CRDT context, throw error (data migration required)
+            if (existingContext && !crdtData) {
+                throw new MigrationError(`Agent context found but missing CRDT state. ` +
+                    `Data migration required. All contexts must use CRDT format. ` +
+                    `Context ID: ${existing.id}`);
+            }
+        }
+        else {
+            // No existing context, just load (will initialize empty)
+            await this.workingMemory.load();
+        }
+        // Save merged state
+        await this.workingMemory.save();
+    }
+    /**
+     * Saves context to database.
+     *
+     * @throws Error if persistence is not configured
+     */
+    async save() {
+        await this.workingMemory.save();
+    }
+    /**
+     * Loads context from database.
+     *
+     * @throws Error if persistence is not configured
+     */
+    async load() {
+        await this.workingMemory.load();
+    }
+    /**
+     * Gets the underlying WorkingMemory instance.
+     *
+     * @returns WorkingMemory instance
+     */
+    getWorkingMemory() {
+        return this.workingMemory;
+    }
+    /**
+     * Gets session ID.
+     */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /**
+     * Gets agent ID.
+     */
+    getAgentId() {
+        return this.agentId;
+    }
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Agent Integration
+ *
+ * Agent-specific memory and context management.
+ */
+export { AgentContextManager } from './context-manager.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/memory/agent/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/memory/agent/index.js

@@ -0,0 +1,6 @@
+/**
+ * Agent Integration
+ *
+ * Agent-specific memory and context management.
+ */
+export { AgentContextManager } from './context-manager.js';

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

@@ -0,0 +1,13 @@
+/**
+ * CRDT (Conflict-free Replicated Data Types) implementations
+ *
+ * These data structures enable eventual consistency in distributed systems
+ * without requiring coordination between nodes.
+ *
+ * @packageDocumentation
+ */
+export { LWWRegister, type LWWRegisterData } from './lww-register.js';
+export { ORSet, type ORSetData, type ORSetEntry } from './or-set.js';
+export { PNCounter, type PNCounterData } from './pn-counter.js';
+export { VectorClock, type VectorClockComparison, type VectorClockData, } from './vector-clock.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/memory/crdt/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACrE,OAAO,EAAE,KAAK,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AACpE,OAAO,EAAE,SAAS,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/D,OAAO,EACL,WAAW,EACX,KAAK,qBAAqB,EAC1B,KAAK,eAAe,GACrB,MAAM,mBAAmB,CAAA"}

package/dist/memory/crdt/index.js

@@ -0,0 +1,12 @@
+/**
+ * CRDT (Conflict-free Replicated Data Types) implementations
+ *
+ * These data structures enable eventual consistency in distributed systems
+ * without requiring coordination between nodes.
+ *
+ * @packageDocumentation
+ */
+export { LWWRegister } from './lww-register.js';
+export { ORSet } from './or-set.js';
+export { PNCounter } from './pn-counter.js';
+export { VectorClock, } from './vector-clock.js';

package/dist/memory/crdt/lww-register.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Last-Writer-Wins Register (LWW-Register)
+ *
+ * A CRDT that stores a single value where the most recent write wins.
+ * Uses timestamps and node IDs to determine ordering when timestamps are equal.
+ *
+ * IMPORTANT: This register deep clones object/array values to prevent external mutations.
+ * Primitives (strings, numbers, booleans, null) are stored as-is for performance.
+ *
+ * Use cases:
+ * - User preferences
+ * - Agent configurations
+ * - Any single-valued state
+ *
+ * @example
+ * ```typescript
+ * const reg1 = new LWWRegister<string>('node-a', 'initial')
+ * const reg2 = new LWWRegister<string>('node-b', 'initial')
+ *
+ * reg1.set('value-from-a')
+ * reg2.set('value-from-b')
+ *
+ * // Merge resolves to most recent write
+ * const merged = reg1.merge(reg2)
+ * const value = merged.get() // 'value-from-b' (if reg2 was set later)
+ * ```
+ */
+export interface LWWRegisterData<T> {
+    value: T;
+    timestamp: number;
+    nodeId: string;
+    version: number;
+}
+export declare class LWWRegister<T> {
+    private value;
+    private timestamp;
+    private nodeId;
+    private version;
+    /**
+     * Creates a new LWW-Register.
+     * @param nodeId - Unique identifier for this node
+     * @param initialValue - The initial value
+     * @param timestamp - Optional initial timestamp (defaults to now)
+     */
+    constructor(nodeId: string, initialValue: T, timestamp?: number);
+    /**
+     * Determines if a value should be deep cloned.
+     * Only objects and arrays need cloning; primitives are safe to store directly.
+     */
+    private shouldClone;
+    /**
+     * Sets a new value with the current timestamp.
+     * Deep clones object/array values to prevent external mutations.
+     * @param value - The new value to set
+     * @param timestamp - Optional explicit timestamp (defaults to now)
+     */
+    set(value: T, timestamp?: number): void;
+    /**
+     * Gets the current value.
+     * Returns a deep clone of object/array values to prevent external mutations.
+     * @returns The current value stored in the register (cloned if object/array)
+     */
+    get(): T;
+    /**
+     * Gets the timestamp of the last update.
+     * @returns The timestamp when the value was last set
+     */
+    getTimestamp(): number;
+    /**
+     * Gets the current version number.
+     * @returns The number of times this register has been updated
+     */
+    getVersion(): number;
+    /**
+     * Merges another LWW-Register into this one.
+     * The value with the most recent timestamp wins.
+     * @param other - The register to merge
+     * @returns A new merged LWWRegister
+     */
+    merge(other: LWWRegister<T>): LWWRegister<T>;
+    /**
+     * Creates a deep copy of this register.
+     * @returns A new LWWRegister with the same state
+     */
+    clone(): LWWRegister<T>;
+    /**
+     * Serializes the register to a plain object.
+     * @returns A serializable representation
+     */
+    toData(): LWWRegisterData<T>;
+    /**
+     * Deserializes a register from serialized data.
+     * @param data - The serialized register data
+     * @returns A new LWWRegister instance
+     */
+    static fromData<T>(data: LWWRegisterData<T>): LWWRegister<T>;
+    /**
+     * Creates a new register with a generated node ID.
+     * @param initialValue - The initial value
+     * @returns A new LWWRegister with a UUID node ID
+     */
+    static create<T>(initialValue: T): LWWRegister<T>;
+    /**
+     * Returns a string representation for debugging.
+     */
+    toString(): string;
+}
+//# sourceMappingURL=lww-register.d.ts.map

package/dist/memory/crdt/lww-register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lww-register.d.ts","sourceRoot":"","sources":["../../../src/memory/crdt/lww-register.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAKH,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,KAAK,EAAE,CAAC,CAAA;IACR,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,qBAAa,WAAW,CAAC,CAAC;IACxB,OAAO,CAAC,KAAK,CAAG;IAChB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,OAAO,CAAQ;IAEvB;;;;;OAKG;gBACS,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM;IAQ/D;;;OAGG;IACH,OAAO,CAAC,WAAW;IAInB;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAgBvC;;;;OAIG;IACH,GAAG,IAAI,CAAC;IAKR;;;OAGG;IACH,YAAY,IAAI,MAAM;IAItB;;;OAGG;IACH,UAAU,IAAI,MAAM;IAIpB;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;IAmB5C;;;OAGG;IACH,KAAK,IAAI,WAAW,CAAC,CAAC,CAAC;IAMvB;;;OAGG;IACH,MAAM,IAAI,eAAe,CAAC,CAAC,CAAC;IAW5B;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;IAO5D;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;IAIjD;;OAEG;IACH,QAAQ,IAAI,MAAM;CAGnB"}