@pellux/goodvibes-sdk 0.18.3 → 0.18.11

package/dist/platform/state/file-cache.js

@@ -0,0 +1,328 @@
+import { readFileSync } from 'fs';
+import { logger } from '../utils/logger.js';
+/**
+ * FileStateCache — File state tracking with Optimistic Concurrency Control.
+ *
+ * Tracks files that have been read by tools/agents, detects external modifications,
+ * and provides conflict information for OCC workflows.
+ */
+export class FileStateCache {
+    mode;
+    maxMemoryBytes;
+    cache = new Map();
+    totalMemBytes = 0;
+    totalReads = 0;
+    cacheHits = 0;
+    constructor(options) {
+        this.mode = options?.mode ?? 'hash_only';
+        this.maxMemoryBytes = (options?.maxMemoryMB ?? 200) * 1024 * 1024;
+    }
+    // ---------------------------------------------------------------------------
+    // Core API
+    // ---------------------------------------------------------------------------
+    /**
+     * Look up the current state of a file.
+     *
+     * - miss: file has never been cached
+     * - unchanged: content hash matches what we last saw
+     * - modified: content hash differs (external modification)
+     *
+     * In `with_content` mode, a unified diff is included when status is 'modified'.
+     */
+    lookup(filePath) {
+        this.totalReads++;
+        const node = this.cache.get(filePath);
+        if (!node) {
+            return { status: 'miss' };
+        }
+        // Re-read file to detect external changes
+        let currentContent;
+        let currentHash;
+        try {
+            currentContent = readFileSync(filePath, 'utf-8');
+            currentHash = this.hash(currentContent);
+        }
+        catch {
+            // File no longer exists or unreadable
+            return { status: 'miss' };
+        }
+        node.accessAt = Date.now();
+        if (currentHash === node.entry.contentHash) {
+            this.cacheHits++;
+            node.entry.lastReadAt = Date.now();
+            node.entry.readCount++;
+            node.entry.tokensSaved += node.entry.tokenEstimate;
+            return { status: 'unchanged', entry: { ...node.entry } };
+        }
+        // Modified externally — return modified status with optional diff
+        let diff;
+        if (this.mode === 'with_content' && node.entry.content !== undefined) {
+            diff = unifiedDiff(node.entry.content, currentContent, filePath);
+        }
+        // Update version and hash to reflect the detected change
+        node.entry.version++;
+        node.entry.contentHash = currentHash;
+        if (this.mode === 'with_content') {
+            const oldMem = node.memBytes;
+            node.entry.content = currentContent;
+            node.memBytes = estimateMemBytes(filePath, currentContent);
+            this.totalMemBytes += node.memBytes - oldMem;
+        }
+        node.entry.lastReadAt = Date.now();
+        node.entry.readCount++;
+        return { status: 'modified', entry: { ...node.entry }, diff };
+    }
+    /**
+     * Record that a file was read or written by a tool/agent.
+     * Creates or updates the cache entry.
+     */
+    update(filePath, content, metadata) {
+        const hash = this.hash(content);
+        const lineCount = content.split('\n').length;
+        const byteSize = Buffer.byteLength(content, 'utf-8');
+        const tokenEstimate = Math.ceil(byteSize / 4);
+        const now = Date.now();
+        const existing = this.cache.get(filePath);
+        if (existing) {
+            const oldMem = existing.memBytes;
+            existing.entry.contentHash = hash;
+            existing.entry.lineCount = lineCount;
+            existing.entry.byteSize = byteSize;
+            existing.entry.tokenEstimate = tokenEstimate;
+            existing.entry.lastReadAt = now;
+            existing.entry.readCount++;
+            existing.entry.version++;
+            if (this.mode === 'with_content') {
+                existing.entry.content = content;
+            }
+            existing.accessAt = now;
+            existing.memBytes = estimateMemBytes(filePath, this.mode === 'with_content' ? content : '');
+            this.totalMemBytes += existing.memBytes - oldMem;
+        }
+        else {
+            const entry = {
+                contentHash: hash,
+                lineCount,
+                byteSize,
+                firstReadAt: now,
+                lastReadAt: now,
+                readCount: 1,
+                tokenEstimate,
+                tokensSaved: 0,
+                version: 1,
+            };
+            if (this.mode === 'with_content') {
+                entry.content = content;
+            }
+            const memBytes = estimateMemBytes(filePath, this.mode === 'with_content' ? content : '');
+            const node = { filePath, entry, memBytes, accessAt: now };
+            this.cache.set(filePath, node);
+            this.totalMemBytes += memBytes;
+        }
+        if (metadata?.tool) {
+            logger.debug('FileStateCache: updated', { filePath, tool: metadata.tool, version: this.cache.get(filePath)?.entry.version });
+        }
+        this.evictIfNeeded();
+    }
+    /**
+     * Check for an OCC conflict: has the file been modified since `expectedVersion`?
+     * Returns null if no conflict, or ConflictInfo if the version has advanced.
+     */
+    checkConflict(filePath, expectedVersion) {
+        const node = this.cache.get(filePath);
+        if (!node)
+            return null;
+        if (node.entry.version === expectedVersion)
+            return null;
+        return {
+            yourVersion: expectedVersion,
+            currentVersion: node.entry.version,
+            diffSinceRead: undefined, // diff on demand only
+        };
+    }
+    /**
+     * Remove a file from the cache.
+     */
+    invalidate(filePath) {
+        const node = this.cache.get(filePath);
+        if (node) {
+            this.totalMemBytes -= node.memBytes;
+            this.cache.delete(filePath);
+        }
+    }
+    /**
+     * Return cache statistics.
+     */
+    getStats() {
+        let tokensSaved = 0;
+        for (const node of this.cache.values()) {
+            tokensSaved += node.entry.tokensSaved;
+        }
+        return {
+            uniqueFiles: this.cache.size,
+            totalReads: this.totalReads,
+            hitRate: this.totalReads > 0 ? this.cacheHits / this.totalReads : 0,
+            tokensSaved,
+            memoryMB: this.totalMemBytes / (1024 * 1024),
+        };
+    }
+    /**
+     * Clear all cached entries.
+     */
+    clear() {
+        this.cache.clear();
+        this.totalMemBytes = 0;
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    hash(content) {
+        const hasher = new Bun.CryptoHasher('sha256');
+        hasher.update(content);
+        return hasher.digest('hex');
+    }
+    evictIfNeeded() {
+        if (this.totalMemBytes <= this.maxMemoryBytes)
+            return;
+        // Sort by oldest access time, evict until under budget
+        const nodes = Array.from(this.cache.values()).sort((a, b) => a.accessAt - b.accessAt);
+        for (const node of nodes) {
+            if (this.totalMemBytes <= this.maxMemoryBytes)
+                break;
+            this.totalMemBytes -= node.memBytes;
+            this.cache.delete(node.filePath);
+            logger.debug('FileStateCache: LRU evict', { filePath: node.filePath });
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Module-level helpers
+// ---------------------------------------------------------------------------
+/**
+ * Estimate in-memory footprint for a cache node.
+ */
+function estimateMemBytes(filePath, content) {
+    return filePath.length * 2 + content.length * 2 + 256; // 256 bytes overhead for entry fields
+}
+/**
+ * Generate a simple unified diff between two strings.
+ * Uses line-by-line LCS diff, not the Myers algorithm.
+ */
+export function unifiedDiff(oldContent, newContent, label, contextLines = 3) {
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
+    const hunks = computeHunks(oldLines, newLines, contextLines);
+    if (hunks.length === 0)
+        return '';
+    const header = `--- ${label}\n+++ ${label}\n`;
+    return header + hunks.join('');
+}
+function computeHunks(oldLines, newLines, CONTEXT = 3) {
+    // Simple O(n*m) LCS-based diff — practical for reasonable file sizes
+    const edits = computeEdits(oldLines, newLines);
+    if (edits.length === 0)
+        return [];
+    // Group edits into hunks with context
+    const result = [];
+    let i = 0;
+    while (i < edits.length) {
+        // Find next non-context edit
+        while (i < edits.length && edits[i].type === 'context')
+            i++;
+        if (i >= edits.length)
+            break;
+        // Collect hunk starting CONTEXT lines before
+        const hunkStart = Math.max(0, i - CONTEXT);
+        let hunkEnd = i;
+        // Extend to next gap
+        while (hunkEnd < edits.length) {
+            if (edits[hunkEnd].type !== 'context') {
+                hunkEnd++;
+            }
+            else {
+                // Check if there's another non-context within CONTEXT distance
+                let next = hunkEnd + 1;
+                while (next < edits.length && edits[next].type === 'context')
+                    next++;
+                if (next < edits.length && next - hunkEnd <= CONTEXT * 2) {
+                    hunkEnd = next;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        const hunkRealEnd = Math.min(edits.length, hunkEnd + CONTEXT);
+        const hunkLines = edits.slice(hunkStart, hunkRealEnd);
+        let oldStart = 1, oldCount = 0, newStart = 1, newCount = 0;
+        // Compute line numbers
+        let oldLine = 1;
+        let newLine = 1;
+        for (let j = 0; j < hunkStart; j++) {
+            if (edits[j].type !== 'added')
+                oldLine++;
+            if (edits[j].type !== 'removed')
+                newLine++;
+        }
+        oldStart = oldLine;
+        newStart = newLine;
+        for (const hl of hunkLines) {
+            if (hl.type !== 'added')
+                oldCount++;
+            if (hl.type !== 'removed')
+                newCount++;
+        }
+        let hunk = `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@\n`;
+        for (const hl of hunkLines) {
+            const prefix = hl.type === 'context' ? ' ' : hl.type === 'removed' ? '-' : '+';
+            hunk += prefix + hl.text + '\n';
+        }
+        result.push(hunk);
+        i = hunkRealEnd;
+    }
+    return result;
+}
+function computeEdits(oldLines, newLines) {
+    // Build LCS table
+    const m = oldLines.length;
+    const n = newLines.length;
+    // For large files, fall back to simple append diff to avoid O(mn) memory
+    if (m * n > 1_000_000) {
+        const edits = [];
+        for (const l of oldLines)
+            edits.push({ type: 'removed', text: l });
+        for (const l of newLines)
+            edits.push({ type: 'added', text: l });
+        return edits;
+    }
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = m - 1; i >= 0; i--) {
+        for (let j = n - 1; j >= 0; j--) {
+            if (oldLines[i] === newLines[j]) {
+                dp[i][j] = dp[i + 1][j + 1] + 1;
+            }
+            else {
+                dp[i][j] = Math.max(dp[i + 1][j], dp[i][j + 1]);
+            }
+        }
+    }
+    // Reconstruct diff
+    const edits = [];
+    let i = 0, j = 0;
+    while (i < m || j < n) {
+        if (i < m && j < n && oldLines[i] === newLines[j]) {
+            edits.push({ type: 'context', text: oldLines[i] });
+            i++;
+            j++;
+        }
+        else if (j < n && (i >= m || (dp[i + 1]?.[j] ?? 0) <= (dp[i]?.[j + 1] ?? 0))) {
+            edits.push({ type: 'added', text: newLines[j] });
+            j++;
+        }
+        else {
+            edits.push({ type: 'removed', text: oldLines[i] });
+            i++;
+        }
+    }
+    return edits;
+}

package/dist/platform/state/file-undo.d.ts

@@ -0,0 +1,46 @@
+export interface FileOperation {
+    /** Absolute resolved path to the file. */
+    path: string;
+    /** File content before the operation. Null if the file did not exist. */
+    beforeContent: string | null;
+    /** File content after the operation. */
+    afterContent: string;
+    /** Human-readable label, e.g. "write" or "edit". */
+    tool: 'write' | 'edit';
+    /** ISO timestamp of the operation. */
+    timestamp: string;
+}
+export declare class FileUndoManager {
+    private undoStack;
+    private redoStack;
+    /**
+     * Record a completed file operation for potential undo/redo.
+     * beforeContent is null when the file was newly created.
+     */
+    snapshot(op: Omit<FileOperation, 'timestamp'>): void;
+    /**
+     * Revert the most recent file operation.
+     * Returns `{ path }` on success, or `null` if nothing to undo.
+     */
+    undo(): {
+        path: string;
+        tool: string;
+    } | null;
+    /**
+     * Re-apply the most recently undone file operation.
+     * Returns `{ path }` on success, or `null` if nothing to redo.
+     */
+    redo(): {
+        path: string;
+        tool: string;
+    } | null;
+    /** Number of operations that can be undone. */
+    undoDepth(): number;
+    /** Number of operations that can be redone. */
+    redoDepth(): number;
+    /** Peek at the most recent undoable operation without popping. */
+    peekUndo(): FileOperation | undefined;
+    /** Clear both stacks (e.g., on session reset). */
+    clear(): void;
+}
+//# sourceMappingURL=file-undo.d.ts.map

package/dist/platform/state/file-undo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-undo.d.ts","sourceRoot":"","sources":["../../../src/platform/state/file-undo.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,aAAa;IAC5B,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,yEAAyE;IACzE,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,wCAAwC;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,oDAAoD;IACpD,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;IACvB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;CACnB;AAQD,qBAAa,eAAe;IAC1B,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,SAAS,CAAuB;IAMxC;;;OAGG;IACH,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,aAAa,EAAE,WAAW,CAAC,GAAG,IAAI;IAgBpD;;;OAGG;IACH,IAAI,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAiC7C;;;OAGG;IACH,IAAI,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAwB7C,+CAA+C;IAC/C,SAAS,IAAI,MAAM;IAInB,+CAA+C;IAC/C,SAAS,IAAI,MAAM;IAInB,kEAAkE;IAClE,QAAQ,IAAI,aAAa,GAAG,SAAS;IAIrC,kDAAkD;IAClD,KAAK,IAAI,IAAI;CAId"}

package/dist/platform/state/file-undo.js

@@ -0,0 +1,110 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { logger } from '../utils/logger.js';
+import { summarizeError } from '../utils/error-display.js';
+// ---------------------------------------------------------------------------
+// FileUndoManager
+// ---------------------------------------------------------------------------
+const MAX_STACK_SIZE = 50;
+export class FileUndoManager {
+    undoStack = [];
+    redoStack = [];
+    // ---------------------------------------------------------------------------
+    // Snapshot — called by write/edit tools after a successful write
+    // ---------------------------------------------------------------------------
+    /**
+     * Record a completed file operation for potential undo/redo.
+     * beforeContent is null when the file was newly created.
+     */
+    snapshot(op) {
+        const entry = { ...op, timestamp: new Date().toISOString() };
+        this.undoStack.push(entry);
+        // Trim to max stack size — remove oldest entries first
+        if (this.undoStack.length > MAX_STACK_SIZE) {
+            this.undoStack.shift();
+        }
+        // Any new operation invalidates the redo stack
+        this.redoStack = [];
+    }
+    // ---------------------------------------------------------------------------
+    // Undo
+    // ---------------------------------------------------------------------------
+    /**
+     * Revert the most recent file operation.
+     * Returns `{ path }` on success, or `null` if nothing to undo.
+     */
+    undo() {
+        const op = this.undoStack.pop();
+        if (!op)
+            return null;
+        try {
+            if (op.beforeContent === null) {
+                // File was created by this op — restoring means deleting it,
+                // but we do a safe approach: write empty string + push to redo.
+                // Full deletion would be destructive; leave as empty file instead.
+                writeFileSync(op.path, '', 'utf-8');
+                logger.debug('file-undo: reverted new file to empty', { path: op.path });
+            }
+            else {
+                writeFileSync(op.path, op.beforeContent, 'utf-8');
+                logger.debug('file-undo: restored previous content', { path: op.path });
+            }
+        }
+        catch (err) {
+            logger.debug('file-undo: undo write failed', { path: op.path, error: summarizeError(err) });
+            // Put it back on the stack so state is consistent
+            this.undoStack.push(op);
+            throw err;
+        }
+        this.redoStack.push(op);
+        if (this.redoStack.length > MAX_STACK_SIZE) {
+            this.redoStack.shift();
+        }
+        return { path: op.path, tool: op.tool };
+    }
+    // ---------------------------------------------------------------------------
+    // Redo
+    // ---------------------------------------------------------------------------
+    /**
+     * Re-apply the most recently undone file operation.
+     * Returns `{ path }` on success, or `null` if nothing to redo.
+     */
+    redo() {
+        const op = this.redoStack.pop();
+        if (!op)
+            return null;
+        try {
+            writeFileSync(op.path, op.afterContent, 'utf-8');
+            logger.debug('file-undo: re-applied operation', { path: op.path });
+        }
+        catch (err) {
+            logger.debug('file-undo: redo write failed', { path: op.path, error: summarizeError(err) });
+            this.redoStack.push(op);
+            throw err;
+        }
+        this.undoStack.push(op);
+        if (this.undoStack.length > MAX_STACK_SIZE) {
+            this.undoStack.shift();
+        }
+        return { path: op.path, tool: op.tool };
+    }
+    // ---------------------------------------------------------------------------
+    // Introspection
+    // ---------------------------------------------------------------------------
+    /** Number of operations that can be undone. */
+    undoDepth() {
+        return this.undoStack.length;
+    }
+    /** Number of operations that can be redone. */
+    redoDepth() {
+        return this.redoStack.length;
+    }
+    /** Peek at the most recent undoable operation without popping. */
+    peekUndo() {
+        return this.undoStack[this.undoStack.length - 1];
+    }
+    /** Clear both stacks (e.g., on session reset). */
+    clear() {
+        this.undoStack = [];
+        this.redoStack = [];
+    }
+}

package/dist/platform/state/json-file-store.d.ts

@@ -0,0 +1,16 @@
+/**
+ * JsonFileStore — generic JSON file persistence with atomic writes.
+ *
+ * Handles lazy loading, atomic writes via a temporary file, and ensures the
+ * directory hierarchy exists. Errors are logged but not re-thrown so that the
+ * caller can decide how to recover.
+ */
+export declare class JsonFileStore<T> {
+    private readonly filePath;
+    constructor(filePath: string);
+    /** Load JSON data from disk, or return null if the file does not exist or is invalid. */
+    load(): Promise<T | null>;
+    /** Atomically persist data to disk. */
+    save(data: T): Promise<void>;
+}
+//# sourceMappingURL=json-file-store.d.ts.map

package/dist/platform/state/json-file-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-file-store.d.ts","sourceRoot":"","sources":["../../../src/platform/state/json-file-store.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,qBAAa,aAAa,CAAC,CAAC;IACd,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,MAAM;IAE7C,yFAAyF;IACnF,IAAI,IAAI,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAc/B,uCAAuC;IACjC,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAWnC"}

package/dist/platform/state/json-file-store.js

@@ -0,0 +1,44 @@
+import { promises as fs, existsSync, mkdirSync, renameSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { logger } from '../utils/logger.js';
+import { summarizeError } from '../utils/error-display.js';
+/**
+ * JsonFileStore — generic JSON file persistence with atomic writes.
+ *
+ * Handles lazy loading, atomic writes via a temporary file, and ensures the
+ * directory hierarchy exists. Errors are logged but not re-thrown so that the
+ * caller can decide how to recover.
+ */
+export class JsonFileStore {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    /** Load JSON data from disk, or return null if the file does not exist or is invalid. */
+    async load() {
+        if (!existsSync(this.filePath)) {
+            return null;
+        }
+        try {
+            const raw = await fs.readFile(this.filePath, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            logger.debug('JsonFileStore: failed to load, starting fresh', { file: this.filePath, error: summarizeError(err) });
+            return null;
+        }
+    }
+    /** Atomically persist data to disk. */
+    async save(data) {
+        try {
+            mkdirSync(dirname(this.filePath), { recursive: true });
+            const tmpPath = `${this.filePath}.tmp`;
+            const content = JSON.stringify(data, null, 2) + '\n';
+            await fs.writeFile(tmpPath, content, 'utf-8');
+            renameSync(tmpPath, this.filePath);
+        }
+        catch (err) {
+            logger.debug('JsonFileStore: save failed (non-fatal)', { file: this.filePath, error: summarizeError(err) });
+        }
+    }
+}

package/dist/platform/state/kv-state.d.ts

@@ -0,0 +1,42 @@
+export interface KVStateOptions {
+    readonly sessionId?: string;
+    readonly stateDir: string;
+}
+/**
+ * KVState — Session-scoped persistent key-value store.
+ *
+ * Storage: <stateDir>/session_{id}.json
+ * Session ID: 8-char hex string, auto-generated if not provided.
+ *
+ * Features:
+ * - Lazy load: defers disk read until first operation.
+ * - Atomic persistence: write to temp file then rename.
+ * - Debounced auto-persist: 5-second timer after each set().
+ */
+export declare class KVState {
+    private sessionId;
+    private stateDir;
+    private filePath;
+    private data;
+    private persistTimer;
+    private loadPromise;
+    private readonly store;
+    constructor(options: KVStateOptions);
+    constructor(sessionId?: string, storageRoot?: string);
+    get(keys: string[]): Promise<Record<string, unknown>>;
+    set(values: Record<string, unknown>): Promise<void>;
+    list(prefix?: string): Promise<Record<string, unknown>>;
+    clear(keys: string[]): Promise<void>;
+    load(): Promise<void>;
+    persist(): Promise<void>;
+    getSessionId(): string;
+    static listSessions(options: Pick<KVStateOptions, 'stateDir'>): string[];
+    static listSessions(storageRoot?: string): string[];
+    static cleanupOldSessions(keepCount: number, options: Pick<KVStateOptions, 'stateDir'>): void;
+    static cleanupOldSessions(keepCount: number, storageRoot?: string): void;
+    dispose(): Promise<void>;
+    private ensureLoaded;
+    private schedulePersist;
+    private static generateId;
+}
+//# sourceMappingURL=kv-state.d.ts.map

package/dist/platform/state/kv-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kv-state.d.ts","sourceRoot":"","sources":["../../../src/platform/state/kv-state.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AA0BD;;;;;;;;;;GAUG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,IAAI,CAAwC;IACpD,OAAO,CAAC,YAAY,CAA8C;IAClE,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyC;gBAEnD,OAAO,EAAE,cAAc;gBACvB,SAAS,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM;IAS9C,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAWrD,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAYnD,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAevD,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAapC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAerB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAK9B,YAAY,IAAI,MAAM;IAItB,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,UAAU,CAAC,GAAG,MAAM,EAAE;IACxE,MAAM,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE;IAgBnD,MAAM,CAAC,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,UAAU,CAAC,GAAG,IAAI;IAC7F,MAAM,CAAC,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI;IAoClE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;YAQhB,YAAY;IAU1B,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,MAAM,CAAC,UAAU;CAS1B"}