agentic-qe 3.3.4 → 3.4.0

package/v3/dist/memory/crdt/g-counter.js

@@ -0,0 +1,134 @@
+/**
+ * Grow-only Counter Implementation
+ *
+ * A CRDT counter that only supports increment operations.
+ * Each node maintains its own count, and the total is the sum of all counts.
+ * Merge takes the maximum of each node's count.
+ *
+ * @module memory/crdt/g-counter
+ */
+// =============================================================================
+// G-Counter Implementation
+// =============================================================================
+/**
+ * Create a new G-Counter
+ *
+ * @param nodeId - Unique identifier for this node
+ * @returns G-Counter instance
+ *
+ * @example
+ * ```typescript
+ * const counter = createGCounter('node-1');
+ * counter.increment(5);
+ * counter.increment();
+ * console.log(counter.get()); // 6
+ * ```
+ */
+export function createGCounter(nodeId) {
+    // Internal state: per-node counts
+    const state = {
+        counts: {},
+        version: 0,
+        lastUpdated: Date.now(),
+    };
+    // Initialize this node's count
+    state.counts[nodeId] = 0;
+    return {
+        get() {
+            // Sum all node counts
+            return Object.values(state.counts).reduce((sum, count) => sum + count, 0);
+        },
+        increment(n = 1) {
+            if (n < 0) {
+                throw new Error('G-Counter can only increment by positive values');
+            }
+            if (n === 0) {
+                return;
+            }
+            state.counts[nodeId] = (state.counts[nodeId] || 0) + n;
+            state.version++;
+            state.lastUpdated = Date.now();
+        },
+        merge(other) {
+            const otherState = other.getState();
+            this.applyState(otherState);
+        },
+        getState() {
+            // Return a deep copy to prevent external mutation
+            return {
+                counts: { ...state.counts },
+                version: state.version,
+                lastUpdated: state.lastUpdated,
+            };
+        },
+        applyState(incoming) {
+            let changed = false;
+            // Merge counts: take max for each node
+            for (const [incomingNodeId, incomingCount] of Object.entries(incoming.counts)) {
+                const currentCount = state.counts[incomingNodeId] || 0;
+                if (incomingCount > currentCount) {
+                    state.counts[incomingNodeId] = incomingCount;
+                    changed = true;
+                }
+            }
+            if (changed) {
+                state.version = Math.max(state.version, incoming.version) + 1;
+                state.lastUpdated = Date.now();
+            }
+        },
+        getNodeId() {
+            return nodeId;
+        },
+        getLocalCount() {
+            return state.counts[nodeId] || 0;
+        },
+    };
+}
+// =============================================================================
+// Factory with State
+// =============================================================================
+/**
+ * Create a G-Counter from existing state
+ *
+ * @param nodeId - Unique identifier for this node
+ * @param existingState - State to restore from
+ * @returns G-Counter instance
+ */
+export function createGCounterFromState(nodeId, existingState) {
+    const counter = createGCounter(nodeId);
+    counter.applyState(existingState);
+    return counter;
+}
+// =============================================================================
+// Type Guards
+// =============================================================================
+/**
+ * Check if a value is a valid G-Counter state
+ */
+export function isGCounterState(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const state = value;
+    return (typeof state.counts === 'object' &&
+        state.counts !== null &&
+        typeof state.version === 'number' &&
+        typeof state.lastUpdated === 'number' &&
+        Object.values(state.counts).every((v) => typeof v === 'number' && v >= 0));
+}
+// =============================================================================
+// Utilities
+// =============================================================================
+/**
+ * Get the count for a specific node from state
+ */
+export function getNodeCountFromState(state, nodeId) {
+    return state.counts[nodeId] || 0;
+}
+/**
+ * Get all contributing nodes from state
+ */
+export function getContributingNodes(state) {
+    return Object.keys(state.counts).filter((k) => state.counts[k] > 0);
+}
+//# sourceMappingURL=g-counter.js.map

package/v3/dist/memory/crdt/g-counter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"g-counter.js","sourceRoot":"","sources":["../../../src/memory/crdt/g-counter.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,52 @@
+/**
+ * CRDT Module - Conflict-free Replicated Data Types
+ *
+ * Provides eventually consistent distributed state for multi-agent coordination.
+ * Implements standard CRDTs with support for delta-based replication.
+ *
+ * @module memory/crdt
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   createCRDTStore,
+ *   createConvergenceTracker,
+ * } from '@agentic-qe/v3/memory/crdt';
+ *
+ * // Agent A creates store
+ * const storeA = createCRDTStore({ nodeId: 'agent-a' });
+ * storeA.setRegister('config', { maxAgents: 100 });
+ * storeA.incrementCounter('tasks');
+ * storeA.addToSet('active', 'agent-a');
+ *
+ * // Agent B creates store (concurrent)
+ * const storeB = createCRDTStore({ nodeId: 'agent-b' });
+ * storeB.incrementCounter('tasks');
+ * storeB.addToSet('active', 'agent-b');
+ *
+ * // Merge stores (order doesn't matter)
+ * storeA.merge(storeB);
+ * storeB.merge(storeA);
+ *
+ * // Both converge to same state
+ * console.log(storeA.getCounter('tasks').get()); // 2
+ * console.log(storeB.getCounter('tasks').get()); // 2
+ *
+ * // Track convergence across cluster
+ * const tracker = createConvergenceTracker();
+ * tracker.recordNodeState('agent-a', storeA.getState());
+ * tracker.recordNodeState('agent-b', storeB.getState());
+ * console.log(tracker.hasConverged()); // true
+ * ```
+ */
+export type { CRDTType, CRDTBaseState, LWWRegister, LWWRegisterState, GCounter, GCounterState, PNCounter, PNCounterState, ORSet, ORSetState, ORSetElement, CRDTStore, CRDTStoreConfig, CRDTStoreState, CRDTStoreDelta, CRDTStoreStats, CRDTChangeEvent, CRDTChangeListener, ConvergenceTracker, ConvergenceTrackerConfig, ConvergenceStatus, NodeStateSnapshot, SerializationOptions, MergeResult, } from './types.js';
+export { createLWWRegister, createLWWRegisterFromState, isLWWRegisterState, } from './lww-register.js';
+export { createGCounter, createGCounterFromState, isGCounterState, getNodeCountFromState, getContributingNodes, } from './g-counter.js';
+export { createPNCounter, createPNCounterFromState, isPNCounterState, getPNCounterBreakdown, } from './pn-counter.js';
+export type { PNCounterBreakdown } from './pn-counter.js';
+export { createORSet, createORSetFromState, isORSetState, getORSetStats, compactORSetState, } from './or-set.js';
+export type { ORSetStats } from './or-set.js';
+export { createCRDTStore, createCRDTStoreFromState, isCRDTStoreState, isCRDTStoreDelta, } from './crdt-store.js';
+export { createConvergenceTracker, createMetricsConvergenceTracker, } from './convergence-tracker.js';
+export type { ConvergenceMetrics, MetricsConvergenceTracker, } from './convergence-tracker.js';
+//# sourceMappingURL=index.d.ts.map

package/v3/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAMH,YAAY,EAEV,QAAQ,EACR,aAAa,EAGb,WAAW,EACX,gBAAgB,EAGhB,QAAQ,EACR,aAAa,EAGb,SAAS,EACT,cAAc,EAGd,KAAK,EACL,UAAU,EACV,YAAY,EAGZ,SAAS,EACT,eAAe,EACf,cAAc,EACd,cAAc,EACd,cAAc,EACd,eAAe,EACf,kBAAkB,EAGlB,kBAAkB,EAClB,wBAAwB,EACxB,iBAAiB,EACjB,iBAAiB,EAGjB,oBAAoB,EACpB,WAAW,GACZ,MAAM,YAAY,CAAC;AAMpB,OAAO,EACL,iBAAiB,EACjB,0BAA0B,EAC1B,kBAAkB,GACnB,MAAM,mBAAmB,CAAC;AAM3B,OAAO,EACL,cAAc,EACd,uBAAuB,EACvB,eAAe,EACf,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,gBAAgB,CAAC;AAMxB,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,iBAAiB,CAAC;AAEzB,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAM1D,OAAO,EACL,WAAW,EACX,oBAAoB,EACpB,YAAY,EACZ,aAAa,EACb,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAM9C,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AAMzB,OAAO,EACL,wBAAwB,EACxB,+BAA+B,GAChC,MAAM,0BAA0B,CAAC;AAElC,YAAY,EACV,kBAAkB,EAClB,yBAAyB,GAC1B,MAAM,0BAA0B,CAAC"}

package/v3/dist/memory/crdt/index.js

@@ -0,0 +1,66 @@
+/**
+ * CRDT Module - Conflict-free Replicated Data Types
+ *
+ * Provides eventually consistent distributed state for multi-agent coordination.
+ * Implements standard CRDTs with support for delta-based replication.
+ *
+ * @module memory/crdt
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   createCRDTStore,
+ *   createConvergenceTracker,
+ * } from '@agentic-qe/v3/memory/crdt';
+ *
+ * // Agent A creates store
+ * const storeA = createCRDTStore({ nodeId: 'agent-a' });
+ * storeA.setRegister('config', { maxAgents: 100 });
+ * storeA.incrementCounter('tasks');
+ * storeA.addToSet('active', 'agent-a');
+ *
+ * // Agent B creates store (concurrent)
+ * const storeB = createCRDTStore({ nodeId: 'agent-b' });
+ * storeB.incrementCounter('tasks');
+ * storeB.addToSet('active', 'agent-b');
+ *
+ * // Merge stores (order doesn't matter)
+ * storeA.merge(storeB);
+ * storeB.merge(storeA);
+ *
+ * // Both converge to same state
+ * console.log(storeA.getCounter('tasks').get()); // 2
+ * console.log(storeB.getCounter('tasks').get()); // 2
+ *
+ * // Track convergence across cluster
+ * const tracker = createConvergenceTracker();
+ * tracker.recordNodeState('agent-a', storeA.getState());
+ * tracker.recordNodeState('agent-b', storeB.getState());
+ * console.log(tracker.hasConverged()); // true
+ * ```
+ */
+// =============================================================================
+// LWW Register Exports
+// =============================================================================
+export { createLWWRegister, createLWWRegisterFromState, isLWWRegisterState, } from './lww-register.js';
+// =============================================================================
+// G-Counter Exports
+// =============================================================================
+export { createGCounter, createGCounterFromState, isGCounterState, getNodeCountFromState, getContributingNodes, } from './g-counter.js';
+// =============================================================================
+// PN-Counter Exports
+// =============================================================================
+export { createPNCounter, createPNCounterFromState, isPNCounterState, getPNCounterBreakdown, } from './pn-counter.js';
+// =============================================================================
+// OR-Set Exports
+// =============================================================================
+export { createORSet, createORSetFromState, isORSetState, getORSetStats, compactORSetState, } from './or-set.js';
+// =============================================================================
+// CRDT Store Exports
+// =============================================================================
+export { createCRDTStore, createCRDTStoreFromState, isCRDTStoreState, isCRDTStoreDelta, } from './crdt-store.js';
+// =============================================================================
+// Convergence Tracker Exports
+// =============================================================================
+export { createConvergenceTracker, createMetricsConvergenceTracker, } from './convergence-tracker.js';
+//# sourceMappingURL=index.js.map

package/v3/dist/memory/crdt/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/memory/crdt/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAgDH,gFAAgF;AAChF,uBAAuB;AACvB,gFAAgF;AAEhF,OAAO,EACL,iBAAiB,EACjB,0BAA0B,EAC1B,kBAAkB,GACnB,MAAM,mBAAmB,CAAC;AAE3B,gFAAgF;AAChF,oBAAoB;AACpB,gFAAgF;AAEhF,OAAO,EACL,cAAc,EACd,uBAAuB,EACvB,eAAe,EACf,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,gBAAgB,CAAC;AAExB,gFAAgF;AAChF,qBAAqB;AACrB,gFAAgF;AAEhF,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,iBAAiB,CAAC;AAIzB,gFAAgF;AAChF,iBAAiB;AACjB,gFAAgF;AAEhF,OAAO,EACL,WAAW,EACX,oBAAoB,EACpB,YAAY,EACZ,aAAa,EACb,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAIrB,gFAAgF;AAChF,qBAAqB;AACrB,gFAAgF;AAEhF,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AAEzB,gFAAgF;AAChF,8BAA8B;AAC9B,gFAAgF;AAEhF,OAAO,EACL,wBAAwB,EACxB,+BAA+B,GAChC,MAAM,0BAA0B,CAAC"}

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

@@ -0,0 +1,40 @@
+/**
+ * Last-Write-Wins Register Implementation
+ *
+ * A CRDT register where concurrent writes are resolved using timestamps.
+ * The write with the highest timestamp wins. In case of ties, the node ID
+ * is used as a tiebreaker (lexicographic order).
+ *
+ * @module memory/crdt/lww-register
+ */
+import type { LWWRegister, LWWRegisterState } from './types.js';
+/**
+ * Create a new LWW Register
+ *
+ * @param nodeId - Unique identifier for this node
+ * @param initialValue - Optional initial value
+ * @param initialTimestamp - Optional initial timestamp
+ * @returns LWW Register instance
+ *
+ * @example
+ * ```typescript
+ * const register = createLWWRegister<string>('node-1');
+ * register.set('hello', Date.now());
+ * console.log(register.get()); // 'hello'
+ * ```
+ */
+export declare function createLWWRegister<T>(nodeId: string, initialValue?: T, initialTimestamp?: number): LWWRegister<T>;
+/**
+ * Create a LWW Register from existing state
+ *
+ * @param nodeId - Unique identifier for this node
+ * @param existingState - State to restore from
+ * @returns LWW Register instance
+ */
+export declare function createLWWRegisterFromState<T>(nodeId: string, existingState: LWWRegisterState<T>): LWWRegister<T>;
+/**
+ * Check if a value is a valid LWW Register state
+ */
+export declare function isLWWRegisterState<T>(value: unknown): value is LWWRegisterState<T>;
+export type { LWWRegister, LWWRegisterState };
+//# sourceMappingURL=lww-register.d.ts.map

package/v3/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;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAMhE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,MAAM,EAAE,MAAM,EACd,YAAY,CAAC,EAAE,CAAC,EAChB,gBAAgB,CAAC,EAAE,MAAM,GACxB,WAAW,CAAC,CAAC,CAAC,CA+FhB;AAMD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAC1C,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,gBAAgB,CAAC,CAAC,CAAC,GACjC,WAAW,CAAC,CAAC,CAAC,CAIhB;AAMD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAAC,CAAC,CAAC,CAalF;AAMD,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,CAAC"}

package/v3/dist/memory/crdt/lww-register.js

@@ -0,0 +1,133 @@
+/**
+ * Last-Write-Wins Register Implementation
+ *
+ * A CRDT register where concurrent writes are resolved using timestamps.
+ * The write with the highest timestamp wins. In case of ties, the node ID
+ * is used as a tiebreaker (lexicographic order).
+ *
+ * @module memory/crdt/lww-register
+ */
+// =============================================================================
+// LWW Register Implementation
+// =============================================================================
+/**
+ * Create a new LWW Register
+ *
+ * @param nodeId - Unique identifier for this node
+ * @param initialValue - Optional initial value
+ * @param initialTimestamp - Optional initial timestamp
+ * @returns LWW Register instance
+ *
+ * @example
+ * ```typescript
+ * const register = createLWWRegister<string>('node-1');
+ * register.set('hello', Date.now());
+ * console.log(register.get()); // 'hello'
+ * ```
+ */
+export function createLWWRegister(nodeId, initialValue, initialTimestamp) {
+    // Internal state
+    let state = {
+        value: initialValue,
+        timestamp: initialTimestamp ?? (initialValue !== undefined ? Date.now() : 0),
+        nodeId: initialValue !== undefined ? nodeId : '',
+        version: initialValue !== undefined ? 1 : 0,
+        lastUpdated: Date.now(),
+    };
+    /**
+     * Compare two timestamps with nodeId as tiebreaker
+     * Returns positive if a wins, negative if b wins, 0 if equal
+     */
+    function compareTimestamps(timestampA, nodeIdA, timestampB, nodeIdB) {
+        if (timestampA !== timestampB) {
+            return timestampA - timestampB;
+        }
+        // Tiebreaker: lexicographic comparison of node IDs
+        return nodeIdA.localeCompare(nodeIdB);
+    }
+    return {
+        get() {
+            return state.value;
+        },
+        set(value, timestamp) {
+            const ts = timestamp ?? Date.now();
+            // Only update if new timestamp wins
+            if (state.timestamp === 0 ||
+                compareTimestamps(ts, nodeId, state.timestamp, state.nodeId) > 0) {
+                state = {
+                    value,
+                    timestamp: ts,
+                    nodeId,
+                    version: state.version + 1,
+                    lastUpdated: Date.now(),
+                };
+            }
+        },
+        merge(other) {
+            const otherState = other.getState();
+            this.applyState(otherState);
+        },
+        getState() {
+            // Return a copy to prevent external mutation
+            return {
+                value: state.value,
+                timestamp: state.timestamp,
+                nodeId: state.nodeId,
+                version: state.version,
+                lastUpdated: state.lastUpdated,
+            };
+        },
+        applyState(incoming) {
+            // Only update if incoming timestamp wins
+            if (state.timestamp === 0 ||
+                compareTimestamps(incoming.timestamp, incoming.nodeId, state.timestamp, state.nodeId) > 0) {
+                state = {
+                    value: incoming.value,
+                    timestamp: incoming.timestamp,
+                    nodeId: incoming.nodeId,
+                    version: Math.max(state.version, incoming.version) + 1,
+                    lastUpdated: Date.now(),
+                };
+            }
+        },
+        getNodeId() {
+            return nodeId;
+        },
+        getTimestamp() {
+            return state.timestamp;
+        },
+    };
+}
+// =============================================================================
+// Factory with State
+// =============================================================================
+/**
+ * Create a LWW Register from existing state
+ *
+ * @param nodeId - Unique identifier for this node
+ * @param existingState - State to restore from
+ * @returns LWW Register instance
+ */
+export function createLWWRegisterFromState(nodeId, existingState) {
+    const register = createLWWRegister(nodeId);
+    register.applyState(existingState);
+    return register;
+}
+// =============================================================================
+// Type Guards
+// =============================================================================
+/**
+ * Check if a value is a valid LWW Register state
+ */
+export function isLWWRegisterState(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const state = value;
+    return (typeof state.timestamp === 'number' &&
+        typeof state.nodeId === 'string' &&
+        typeof state.version === 'number' &&
+        typeof state.lastUpdated === 'number' &&
+        'value' in state);
+}
+//# sourceMappingURL=lww-register.js.map

package/v3/dist/memory/crdt/lww-register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lww-register.js","sourceRoot":"","sources":["../../../src/memory/crdt/lww-register.ts"],"names":[],"mappings":"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"}

package/v3/dist/memory/crdt/or-set.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Observed-Remove Set Implementation
+ *
+ * A CRDT set with add-wins semantics on concurrent add/remove operations.
+ * Each add operation creates a unique tag. Remove operations mark those tags
+ * as tombstones. An element is present if it has at least one tag not in tombstones.
+ *
+ * @module memory/crdt/or-set
+ */
+import type { ORSet, ORSetState } from './types.js';
+/**
+ * Create a new OR-Set
+ *
+ * @param nodeId - Unique identifier for this node
+ * @returns OR-Set instance
+ *
+ * @example
+ * ```typescript
+ * const set = createORSet<string>('node-1');
+ * set.add('apple');
+ * set.add('banana');
+ * set.remove('apple');
+ * console.log(set.values()); // ['banana']
+ * ```
+ */
+export declare function createORSet<T>(nodeId: string): ORSet<T>;
+/**
+ * Create an OR-Set from existing state
+ *
+ * @param nodeId - Unique identifier for this node
+ * @param existingState - State to restore from
+ * @returns OR-Set instance
+ */
+export declare function createORSetFromState<T>(nodeId: string, existingState: ORSetState<T>): ORSet<T>;
+/**
+ * Check if a value is a valid OR-Set state
+ */
+export declare function isORSetState<T>(value: unknown): value is ORSetState<T>;
+/**
+ * Get detailed statistics about an OR-Set
+ */
+export interface ORSetStats {
+    /** Number of active elements */
+    activeElements: number;
+    /** Total tags across all elements */
+    totalTags: number;
+    /** Total tombstoned tags */
+    totalTombstones: number;
+    /** Number of elements with tombstones */
+    elementsWithTombstones: number;
+}
+/**
+ * Get statistics about an OR-Set
+ */
+export declare function getORSetStats<T>(state: ORSetState<T>): ORSetStats;
+/**
+ * Compact OR-Set state by removing fully tombstoned elements
+ * Returns a new state object (does not mutate input)
+ */
+export declare function compactORSetState<T>(state: ORSetState<T>): ORSetState<T>;
+export type { ORSet, ORSetState };
+//# sourceMappingURL=or-set.d.ts.map

package/v3/dist/memory/crdt/or-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"or-set.d.ts","sourceRoot":"","sources":["../../../src/memory/crdt/or-set.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AA4DpD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAgNvD;AAMD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,UAAU,CAAC,CAAC,CAAC,GAC3B,KAAK,CAAC,CAAC,CAAC,CAIV;AAMD;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAAC,CAAC,CAAC,CActE;AAMD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,gCAAgC;IAChC,cAAc,EAAE,MAAM,CAAC;IACvB,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,4BAA4B;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,yCAAyC;IACzC,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CA8BjE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CA0BxE;AAMD,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC"}