claude-flow-novice 1.6.4 → 1.6.6

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/completion/hierarchical-detector.js

@@ -0,0 +1,347 @@
+/**
+ * Agent Coordination V2 - Hierarchical Completion Detection
+ *
+ * PM-based completion detection for hierarchical swarms.
+ * Project Manager checks all children are COMPLETED before declaring completion.
+ *
+ * Performance targets:
+ * - Detection: <1000ms for 20-agent swarm
+ * - Bottom-up traversal (leaves → root)
+ * - Zero false positives via checkpoint validation
+ *
+ * @module coordination/v2/completion/hierarchical-detector
+ */ import { AgentState } from '../../shared/core/agent-state.js';
+import { CompletionDetector } from './completion-detector.js';
+/**
+ * HierarchicalCompletionDetector
+ *
+ * Implements PM-based completion detection pattern:
+ * 1. Leaf agents complete their tasks
+ * 2. PM checks if all children are COMPLETED
+ * 3. If all children complete, PM can complete
+ * 4. Traverse bottom-up until root PM completes
+ * 5. Create checkpoint BEFORE declaring completion
+ *
+ * @example
+ * ```typescript
+ * const detector = new HierarchicalCompletionDetector(
+ *   stateMachine,
+ *   messageBroker,
+ *   checkpointManager,
+ *   dependencyGraph,
+ *   { autoCheckpoint: true }
+ * );
+ *
+ * // Register swarm hierarchy
+ * detector.registerSwarm('swarm-1', 'pm-1', [
+ *   { agentId: 'agent-1', parentId: 'pm-1' },
+ *   { agentId: 'agent-2', parentId: 'pm-1' },
+ * ]);
+ *
+ * // Detect completion (triggered by state transitions)
+ * const result = await detector.detectCompletion('swarm-1');
+ * console.log(result.completed); // true when all agents complete
+ * ```
+ */ export class HierarchicalCompletionDetector extends CompletionDetector {
+    swarms;
+    dependencyGraph;
+    constructor(stateMachine, messageBroker, checkpointManager, dependencyGraph, config){
+        super(stateMachine, messageBroker, checkpointManager, config);
+        this.swarms = new Map();
+        this.dependencyGraph = dependencyGraph;
+        if (this.config.enableLogging) {
+            this.log('HierarchicalCompletionDetector initialized', {
+                hasDependencyGraph: !!dependencyGraph
+            });
+        }
+    }
+    /**
+   * Register swarm hierarchy for completion tracking
+   *
+   * @param swarmId - Swarm identifier
+   * @param rootPmId - Root Project Manager agent ID
+   * @param agents - Agent hierarchy definitions
+   */ registerSwarm(swarmId, rootPmId, agents) {
+        const nodes = new Map();
+        // Build hierarchy nodes
+        for (const agent of agents){
+            const currentState = this.stateMachine.getState(agent.agentId) || AgentState.IDLE;
+            nodes.set(agent.agentId, {
+                agentId: agent.agentId,
+                state: currentState,
+                parentId: agent.parentId,
+                childIds: [],
+                isProjectManager: agent.isProjectManager || agent.agentId === rootPmId,
+                lastUpdated: this.lamportClock.tick()
+            });
+        }
+        // Add root PM if not in agents list
+        if (!nodes.has(rootPmId)) {
+            nodes.set(rootPmId, {
+                agentId: rootPmId,
+                state: this.stateMachine.getState(rootPmId) || AgentState.IDLE,
+                parentId: undefined,
+                childIds: [],
+                isProjectManager: true,
+                lastUpdated: this.lamportClock.tick()
+            });
+        }
+        // Build parent-child relationships
+        for (const node of Array.from(nodes.values())){
+            if (node.parentId) {
+                const parent = nodes.get(node.parentId);
+                if (parent) {
+                    parent.childIds.push(node.agentId);
+                }
+            }
+        }
+        const hierarchy = {
+            swarmId,
+            rootPmId,
+            nodes,
+            dependencyGraph: this.dependencyGraph
+        };
+        this.swarms.set(swarmId, hierarchy);
+        if (this.config.enableLogging) {
+            this.log('Swarm hierarchy registered', {
+                swarmId,
+                rootPmId,
+                totalAgents: nodes.size,
+                pmCount: Array.from(nodes.values()).filter((n)=>n.isProjectManager).length
+            });
+        }
+    }
+    /**
+   * Detect swarm completion using PM-based pattern
+   */ async detectCompletion(swarmId) {
+        const startTime = performance.now();
+        try {
+            const hierarchy = this.swarms.get(swarmId);
+            if (!hierarchy) {
+                throw new Error(`Swarm ${swarmId} not registered`);
+            }
+            // Update all agent states from state machine
+            await this.updateAgentStates(hierarchy);
+            // Check root PM completion (bottom-up traversal implicit via state checks)
+            const allCompleted = this.checkHierarchyCompletion(hierarchy);
+            // Gather agent states
+            const agentStates = new Map();
+            for (const node of Array.from(hierarchy.nodes.values())){
+                agentStates.set(node.agentId, node.state);
+            }
+            const completedCount = Array.from(agentStates.values()).filter((state)=>state === AgentState.COMPLETED).length;
+            let checkpointId;
+            const warnings = [];
+            if (allCompleted) {
+                // Validate completion before declaring
+                if (this.config.enableValidation) {
+                    const validation = await this.validateCompletion(swarmId, agentStates);
+                    if (!validation.valid) {
+                        warnings.push(...validation.errors);
+                        if (this.config.enableLogging) {
+                            this.log('Completion validation failed', {
+                                swarmId,
+                                errors: validation.errors
+                            });
+                        }
+                    }
+                }
+                // Create checkpoint BEFORE declaring completion
+                if (this.config.autoCheckpoint) {
+                    checkpointId = await this.createCompletionCheckpoint(swarmId, agentStates);
+                }
+            }
+            const latencyMs = performance.now() - startTime;
+            const result = {
+                completed: allCompleted,
+                swarmId,
+                timestamp: new Date(),
+                agentStates,
+                completedCount,
+                totalCount: hierarchy.nodes.size,
+                latencyMs,
+                checkpointId,
+                metadata: {
+                    strategy: 'hierarchical',
+                    warnings: warnings.length > 0 ? warnings : undefined,
+                    context: {
+                        rootPmId: hierarchy.rootPmId,
+                        pmCount: Array.from(hierarchy.nodes.values()).filter((n)=>n.isProjectManager).length
+                    }
+                }
+            };
+            this.updateMetrics(latencyMs, true);
+            if (allCompleted) {
+                this.emitCompletionDetected(result);
+            }
+            return result;
+        } catch (error) {
+            const latencyMs = performance.now() - startTime;
+            this.updateMetrics(latencyMs, false);
+            this.emitCompletionFailed(swarmId, error);
+            throw error;
+        }
+    }
+    /**
+   * Validate completion conditions
+   *
+   * Checks:
+   * - All agents in COMPLETED state
+   * - Root PM completed last
+   * - No blocked or error agents
+   * - Dependency graph satisfied (if available)
+   */ async validateCompletion(swarmId, agentStates) {
+        const startTime = performance.now();
+        const errors = [];
+        const warnings = [];
+        const hierarchy = this.swarms.get(swarmId);
+        if (!hierarchy) {
+            errors.push(`Swarm ${swarmId} not registered`);
+            return {
+                valid: false,
+                errors,
+                warnings,
+                latencyMs: performance.now() - startTime
+            };
+        }
+        // Check all agents completed
+        for (const [agentId, state] of Array.from(agentStates.entries())){
+            if (state !== AgentState.COMPLETED) {
+                errors.push(`Agent ${agentId} not completed (state: ${state})`);
+            }
+            if (state === AgentState.BLOCKED || state === AgentState.ERROR) {
+                errors.push(`Agent ${agentId} in error state: ${state}`);
+            }
+        }
+        // Check root PM completed
+        const rootPm = hierarchy.nodes.get(hierarchy.rootPmId);
+        if (rootPm && rootPm.state !== AgentState.COMPLETED) {
+            errors.push(`Root PM ${hierarchy.rootPmId} not completed (state: ${rootPm.state})`);
+        }
+        // Check PM hierarchy completion order (PMs should complete after their children)
+        for (const node of Array.from(hierarchy.nodes.values())){
+            if (node.isProjectManager && node.state === AgentState.COMPLETED) {
+                for (const childId of node.childIds){
+                    const childState = agentStates.get(childId);
+                    if (childState !== AgentState.COMPLETED) {
+                        warnings.push(`PM ${node.agentId} completed before child ${childId}`);
+                    }
+                }
+            }
+        }
+        // Validate dependency graph if available
+        if (hierarchy.dependencyGraph) {
+            const graphStats = hierarchy.dependencyGraph.getStatistics();
+            if (graphStats.completedNodeCount !== graphStats.nodeCount) {
+                errors.push(`Dependency graph incomplete: ${graphStats.completedNodeCount}/${graphStats.nodeCount} completed`);
+            }
+        }
+        const latencyMs = performance.now() - startTime;
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+            latencyMs
+        };
+    }
+    /**
+   * Get detection strategy
+   */ getStrategy() {
+        return 'hierarchical';
+    }
+    /**
+   * Handle state transition events
+   *
+   * Updates agent states and triggers completion checks.
+   * Uses Lamport timestamp for causal ordering.
+   */ handleStateTransition(event) {
+        const { agentId, toState } = event;
+        // Increment Lamport clock for state transition event
+        const lamportTimestamp = this.lamportClock.tick();
+        // Find swarm containing this agent
+        for (const [swarmId, hierarchy] of Array.from(this.swarms.entries())){
+            const node = hierarchy.nodes.get(agentId);
+            if (node) {
+                // Update node state with Lamport timestamp
+                node.state = toState;
+                node.lastUpdated = lamportTimestamp;
+                // If agent completed, check if swarm completion triggered
+                if (toState === AgentState.COMPLETED) {
+                    // Async completion check (don't block state transition)
+                    this.detectCompletion(swarmId).catch((error)=>{
+                        if (this.config.enableLogging) {
+                            this.log('Completion check failed', {
+                                swarmId,
+                                agentId,
+                                error: error.message
+                            });
+                        }
+                    });
+                }
+                break;
+            }
+        }
+    }
+    /**
+   * Check if entire hierarchy completed using PM-based pattern
+   */ checkHierarchyCompletion(hierarchy) {
+        // Check if root PM completed (implies all children completed)
+        const rootPm = hierarchy.nodes.get(hierarchy.rootPmId);
+        if (!rootPm || rootPm.state !== AgentState.COMPLETED) {
+            return false;
+        }
+        // Verify all children completed (bottom-up validation)
+        return this.checkNodeCompletion(rootPm, hierarchy);
+    }
+    /**
+   * Recursively check if node and all children completed
+   */ checkNodeCompletion(node, hierarchy) {
+        // Check node itself completed
+        if (node.state !== AgentState.COMPLETED) {
+            return false;
+        }
+        // Check all children completed
+        for (const childId of node.childIds){
+            const child = hierarchy.nodes.get(childId);
+            if (!child) {
+                return false;
+            }
+            // Recursive check
+            if (!this.checkNodeCompletion(child, hierarchy)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+   * Update agent states from state machine with Lamport timestamps
+   */ async updateAgentStates(hierarchy) {
+        const allStates = this.stateMachine.getAllStates();
+        const lamportTimestamp = this.lamportClock.tick();
+        for (const [agentId, state] of Array.from(allStates.entries())){
+            const node = hierarchy.nodes.get(agentId);
+            if (node) {
+                node.state = state;
+                node.lastUpdated = lamportTimestamp;
+            }
+        }
+    }
+    /**
+   * Unregister swarm
+   */ unregisterSwarm(swarmId) {
+        return this.swarms.delete(swarmId);
+    }
+    /**
+   * Get swarm hierarchy
+   */ getSwarmHierarchy(swarmId) {
+        return this.swarms.get(swarmId);
+    }
+    /**
+   * Cleanup detector resources
+   */ async cleanup() {
+        this.swarms.clear();
+        await super.cleanup();
+    }
+}
+
+//# sourceMappingURL=hierarchical-detector.js.map

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/completion/hierarchical-detector.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/coordination/archives/v2-sdk-typescript/v2/completion/hierarchical-detector.ts"],"names":["AgentState","CompletionDetector","HierarchicalCompletionDetector","swarms","dependencyGraph","stateMachine","messageBroker","checkpointManager","config","Map","enableLogging","log","hasDependencyGraph","registerSwarm","swarmId","rootPmId","agents","nodes","agent","currentState","getState","agentId","IDLE","set","state","parentId","childIds","isProjectManager","lastUpdated","lamportClock","tick","has","undefined","node","Array","from","values","parent","get","push","hierarchy","totalAgents","size","pmCount","filter","n","length","detectCompletion","startTime","performance","now","Error","updateAgentStates","allCompleted","checkHierarchyCompletion","agentStates","completedCount","COMPLETED","checkpointId","warnings","enableValidation","validation","validateCompletion","valid","errors","autoCheckpoint","createCompletionCheckpoint","latencyMs","result","completed","timestamp","Date","totalCount","metadata","strategy","context","updateMetrics","emitCompletionDetected","error","emitCompletionFailed","entries","BLOCKED","ERROR","rootPm","childId","childState","graphStats","getStatistics","completedNodeCount","nodeCount","getStrategy","handleStateTransition","event","toState","lamportTimestamp","catch","message","checkNodeCompletion","child","allStates","getAllStates","unregisterSwarm","delete","getSwarmHierarchy","cleanup","clear"],"mappings":"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"}

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/completion/index.js

@@ -0,0 +1,13 @@
+/**
+ * Agent Coordination V2 - Completion Module
+ *
+ * Exports completion detection, shutdown coordination, and completion storage.
+ *
+ * @module coordination/v2/completion
+ */ export { CompletionDetector, CompletionResult, ValidationResult, CompletionMetrics, ValidationContext, StateSnapshot } from './completion-detector.js';
+export { HierarchicalCompletionDetector } from './hierarchical-detector.js';
+export { MeshCompletionDetector } from './mesh-detector.js';
+export { SDKCompletionDetector, AgentCompletionEventData, SDKCompletionDetectorConfig, CompletionValidationResult, CheckpointValidationResult, RecoveryResult, CompletionDetectorMetrics } from './sdk-completion-detector.js';
+export { SwarmShutdown, SwarmShutdownConfig, AgentShutdownResult, SwarmShutdownResult } from './swarm-shutdown.js';
+
+//# sourceMappingURL=index.js.map

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/completion/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/coordination/archives/v2-sdk-typescript/v2/completion/index.ts"],"names":["CompletionDetector","CompletionResult","ValidationResult","CompletionMetrics","ValidationContext","StateSnapshot","HierarchicalCompletionDetector","MeshCompletionDetector","SDKCompletionDetector","AgentCompletionEventData","SDKCompletionDetectorConfig","CompletionValidationResult","CheckpointValidationResult","RecoveryResult","CompletionDetectorMetrics","SwarmShutdown","SwarmShutdownConfig","AgentShutdownResult","SwarmShutdownResult"],"mappings":"AAAA;;;;;;CAMC,GAED,SACEA,kBAAkB,EAClBC,gBAAgB,EAChBC,gBAAgB,EAChBC,iBAAiB,EACjBC,iBAAiB,EACjBC,aAAa,QACR,2BAA2B;AAIlC,SACEC,8BAA8B,QACzB,6BAA6B;AAEpC,SACEC,sBAAsB,QACjB,qBAAqB;AAE5B,SACEC,qBAAqB,EACrBC,wBAAwB,EACxBC,2BAA2B,EAC3BC,0BAA0B,EAC1BC,0BAA0B,EAC1BC,cAAc,EACdC,yBAAyB,QACpB,+BAA+B;AAEtC,SACEC,aAAa,EACbC,mBAAmB,EACnBC,mBAAmB,EACnBC,mBAAmB,QACd,sBAAsB"}

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/completion/lamport-clock.js

@@ -0,0 +1,173 @@
+/**
+ * Lamport Clock Implementation for Causal Event Ordering
+ *
+ * Provides logical timestamps for distributed event ordering in agent coordination.
+ * Ensures happens-before relationship tracking without physical clock synchronization.
+ *
+ * Use Case: SEC-024 Fix - Replace Date.now() with Lamport timestamps in completion events
+ * to prevent incorrect completion order in distributed mesh topology.
+ *
+ * Algorithm:
+ * - Each process maintains a counter (logical clock)
+ * - Counter increments on local events
+ * - Counter updates on message receive: max(local, received) + 1
+ * - Guarantees: if A happened-before B, then timestamp(A) < timestamp(B)
+ *
+ * @module coordination/v2/completion/lamport-clock
+ */ /**
+ * Lamport Clock for distributed event ordering
+ *
+ * Provides logical timestamps that preserve causal ordering of events
+ * across distributed agents without requiring synchronized physical clocks.
+ *
+ * @example
+ * ```typescript
+ * const clock = new LamportClock();
+ *
+ * // Local event (e.g., agent starts task)
+ * const timestamp1 = clock.tick(); // 1
+ *
+ * // Another local event
+ * const timestamp2 = clock.tick(); // 2
+ *
+ * // Receive message with timestamp 5 from remote agent
+ * const timestamp3 = clock.update(5); // 6 (max(2, 5) + 1)
+ *
+ * // Check causal ordering
+ * if (LamportClock.happenedBefore(timestamp1, timestamp3)) {
+ *   console.log('Event 1 happened before Event 3');
+ * }
+ * ```
+ */ export class LamportClock {
+    counter = 0;
+    /**
+   * Increment clock for local event
+   *
+   * Use this when agent performs local action:
+   * - Agent state transition
+   * - Completion detection
+   * - Internal task completion
+   *
+   * @returns New Lamport timestamp after increment
+   */ tick() {
+        this.counter++;
+        return this.counter;
+    }
+    /**
+   * Update clock when receiving message with remote timestamp
+   *
+   * Use this when agent receives message from another agent:
+   * - Completion probe acknowledgment
+   * - Inter-agent communication
+   * - Coordinator status update
+   *
+   * Ensures happens-before relationship:
+   * If remote event E1 happened before local event E2,
+   * then timestamp(E1) < timestamp(E2)
+   *
+   * @param remoteTimestamp - Lamport timestamp from received message
+   * @returns New local timestamp after synchronization
+   */ update(remoteTimestamp) {
+        this.counter = Math.max(this.counter, remoteTimestamp) + 1;
+        return this.counter;
+    }
+    /**
+   * Get current timestamp without incrementing
+   *
+   * Use this for read-only operations where you need current clock value
+   * but don't want to advance logical time (e.g., debugging, logging).
+   *
+   * @returns Current Lamport timestamp
+   */ getTimestamp() {
+        return this.counter;
+    }
+    /**
+   * Reset clock to initial state (for testing only)
+   *
+   * WARNING: Only use in test scenarios. Resetting clock in production
+   * breaks causal ordering guarantees.
+   */ reset() {
+        this.counter = 0;
+    }
+    /**
+   * Compare two Lamport timestamps for happens-before relation
+   *
+   * Returns true if t1 happened before t2 in logical time.
+   *
+   * Note: Lamport clocks provide partial ordering:
+   * - If happenedBefore(t1, t2) is true, t1 definitely happened before t2
+   * - If happenedBefore(t1, t2) is false, t1 and t2 may be concurrent
+   *
+   * For total ordering, use Vector Clocks (not implemented here).
+   *
+   * @param t1 - First Lamport timestamp
+   * @param t2 - Second Lamport timestamp
+   * @returns True if t1 happened before t2
+   */ static happenedBefore(t1, t2) {
+        return t1 < t2;
+    }
+    /**
+   * Compare two events with Lamport timestamps and tie-breaking IDs
+   *
+   * When two events have same Lamport timestamp (concurrent events),
+   * use agent/process ID for deterministic ordering.
+   *
+   * @param t1 - First Lamport timestamp
+   * @param id1 - First event/agent identifier (for tie-breaking)
+   * @param t2 - Second Lamport timestamp
+   * @param id2 - Second event/agent identifier (for tie-breaking)
+   * @returns -1 if e1 < e2, 0 if e1 == e2, 1 if e1 > e2
+   */ static compareEvents(t1, id1, t2, id2) {
+        if (t1 !== t2) {
+            return t1 < t2 ? -1 : 1;
+        }
+        // Tie-breaking: use lexicographic order of IDs for deterministic ordering
+        return id1.localeCompare(id2);
+    }
+    /**
+   * Serialize clock state (for persistence or network transmission)
+   *
+   * @returns Serializable clock state
+   */ serialize() {
+        return {
+            counter: this.counter
+        };
+    }
+    /**
+   * Deserialize clock state (from persistence or network)
+   *
+   * @param state - Serialized clock state
+   */ deserialize(state) {
+        this.counter = state.counter;
+    }
+}
+/**
+ * Create Lamport-timestamped event
+ *
+ * @param clock - Lamport clock instance
+ * @param eventId - Unique event identifier
+ * @param sourceId - Event source agent/process ID
+ * @param data - Event payload
+ * @returns Lamport-timestamped event
+ */ export function createLamportEvent(clock, eventId, sourceId, data) {
+    return {
+        timestamp: clock.tick(),
+        eventId,
+        sourceId,
+        physicalTime: Date.now(),
+        data
+    };
+}
+/**
+ * Process received Lamport event
+ *
+ * Updates local clock based on received timestamp and returns synchronized clock value.
+ *
+ * @param clock - Local Lamport clock
+ * @param event - Received Lamport event
+ * @returns New local timestamp after synchronization
+ */ export function processLamportEvent(clock, event) {
+    return clock.update(event.timestamp);
+}
+
+//# sourceMappingURL=lamport-clock.js.map

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/completion/lamport-clock.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/coordination/archives/v2-sdk-typescript/v2/completion/lamport-clock.ts"],"names":["LamportClock","counter","tick","update","remoteTimestamp","Math","max","getTimestamp","reset","happenedBefore","t1","t2","compareEvents","id1","id2","localeCompare","serialize","deserialize","state","createLamportEvent","clock","eventId","sourceId","data","timestamp","physicalTime","Date","now","processLamportEvent","event"],"mappings":"AAAA;;;;;;;;;;;;;;;;CAgBC,GAED;;;;;;;;;;;;;;;;;;;;;;;;CAwBC,GACD,OAAO,MAAMA;IACHC,UAAkB,EAAE;IAE5B;;;;;;;;;GASC,GACDC,OAAe;QACb,IAAI,CAACD,OAAO;QACZ,OAAO,IAAI,CAACA,OAAO;IACrB;IAEA;;;;;;;;;;;;;;GAcC,GACDE,OAAOC,eAAuB,EAAU;QACtC,IAAI,CAACH,OAAO,GAAGI,KAAKC,GAAG,CAAC,IAAI,CAACL,OAAO,EAAEG,mBAAmB;QACzD,OAAO,IAAI,CAACH,OAAO;IACrB;IAEA;;;;;;;GAOC,GACDM,eAAuB;QACrB,OAAO,IAAI,CAACN,OAAO;IACrB;IAEA;;;;;GAKC,GACDO,QAAc;QACZ,IAAI,CAACP,OAAO,GAAG;IACjB;IAEA;;;;;;;;;;;;;;GAcC,GACD,OAAOQ,eAAeC,EAAU,EAAEC,EAAU,EAAW;QACrD,OAAOD,KAAKC;IACd;IAEA;;;;;;;;;;;GAWC,GACD,OAAOC,cAAcF,EAAU,EAAEG,GAAW,EAAEF,EAAU,EAAEG,GAAW,EAAU;QAC7E,IAAIJ,OAAOC,IAAI;YACb,OAAOD,KAAKC,KAAK,CAAC,IAAI;QACxB;QAEA,0EAA0E;QAC1E,OAAOE,IAAIE,aAAa,CAACD;IAC3B;IAEA;;;;GAIC,GACDE,YAAiC;QAC/B,OAAO;YAAEf,SAAS,IAAI,CAACA,OAAO;QAAC;IACjC;IAEA;;;;GAIC,GACDgB,YAAYC,KAA0B,EAAQ;QAC5C,IAAI,CAACjB,OAAO,GAAGiB,MAAMjB,OAAO;IAC9B;AACF;AAwBA;;;;;;;;CAQC,GACD,OAAO,SAASkB,mBACdC,KAAmB,EACnBC,OAAe,EACfC,QAAgB,EAChBC,IAAO;IAEP,OAAO;QACLC,WAAWJ,MAAMlB,IAAI;QACrBmB;QACAC;QACAG,cAAcC,KAAKC,GAAG;QACtBJ;IACF;AACF;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASK,oBAAuBR,KAAmB,EAAES,KAAsB;IAChF,OAAOT,MAAMjB,MAAM,CAAC0B,MAAML,SAAS;AACrC"}